CheckBoxButton checkBoxButton2( checkBoxButton );
DALI_TEST_CHECK( checkBoxButton2 );
- checkBoxButton2 = NULL;
+ checkBoxButton2.Reset();
//Additional check to ensure object is created by checking if it's registered
DALI_TEST_CHECK( waveEffect );
- waveEffect = NULL;
+ waveEffect.Reset();
//Additional check to ensure object is created by checking if it's registered
ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
DALI_TEST_CHECK( crossEffect );
- crossEffect = NULL;
+ crossEffect.Reset();
//Additional check to ensure object is created by checking if it's registered
ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
DALI_TEST_CHECK( foldEffect );
- foldEffect = NULL;
+ foldEffect.Reset();
//Additional check to ensure object is created by checking if it is registered
ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
DALI_TEST_CHECK( gainActor == pushButton1 );
DALI_TEST_CHECK( lostActor == Control() );
- gainActor = lostActor = NULL;
+ gainActor.Reset();
+ lostActor.Reset();
manager.SetFocus(pushButton2);
DALI_TEST_CHECK( gainActor == pushButton2 );
DALI_TEST_CHECK( lostActor == pushButton1 );
- gainActor = lostActor = NULL;
+ gainActor.Reset();
+ lostActor.Reset();
// Removing the focus actor from the stage would also result in signal emission.
stage.Remove( pushButton1 );
View view3 = view2;
DALI_TEST_CHECK( view3 );
- view1 = NULL;
- view2 = NULL;
- view3 = NULL;
+ view1.Reset();
+ view2.Reset();
+ view3.Reset();
//Additional check to ensure object is created by checking if it's registered
ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
TestApplication::TestApplication( size_t surfaceWidth,
size_t surfaceHeight,
float horizontalDpi,
- float verticalDpi)
+ float verticalDpi,
+ ResourcePolicy::DataRetention policy)
: mCore( NULL ),
mSurfaceWidth( surfaceWidth ),
mSurfaceHeight( surfaceHeight ),
mFrame( 0u ),
mDpi( horizontalDpi, verticalDpi ),
- mLastVSyncTime(0u)
+ mLastVSyncTime(0u),
+ mDataRetentionPolicy( policy )
{
Initialize();
}
size_t surfaceWidth,
size_t surfaceHeight,
float horizontalDpi,
- float verticalDpi )
+ float verticalDpi,
+ ResourcePolicy::DataRetention policy)
: mCore( NULL ),
mSurfaceWidth( surfaceWidth ),
mSurfaceHeight( surfaceHeight ),
mFrame( 0u ),
- mDpi( horizontalDpi, verticalDpi )
+ mDpi( horizontalDpi, verticalDpi ),
+ mDataRetentionPolicy( policy )
{
if ( initialize )
{
mPlatformAbstraction,
mGlAbstraction,
mGlSyncAbstraction,
- mGestureManager );
+ mGestureManager,
+ mDataRetentionPolicy);
mCore->ContextCreated();
mCore->SurfaceResized( mSurfaceWidth, mSurfaceHeight );
void TestApplication::ResetContext()
{
- mCore->ContextToBeDestroyed();
+ mCore->ContextDestroyed();
mCore->ContextCreated();
}
TestApplication( size_t surfaceWidth = DEFAULT_SURFACE_WIDTH,
size_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
float horizontalDpi = DEFAULT_HORIZONTAL_DPI,
- float verticalDpi = DEFAULT_VERTICAL_DPI );
+ float verticalDpi = DEFAULT_VERTICAL_DPI,
+ ResourcePolicy::DataRetention resourcePolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA );
+
+
TestApplication( bool initialize,
size_t surfaceWidth = DEFAULT_SURFACE_WIDTH,
size_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
float horizontalDpi = DEFAULT_HORIZONTAL_DPI,
- float verticalDpi = DEFAULT_VERTICAL_DPI );
+ float verticalDpi = DEFAULT_VERTICAL_DPI,
+ ResourcePolicy::DataRetention resourcePolicy = ResourcePolicy::DALI_DISCARDS_ALL_DATA );
void Initialize();
virtual ~TestApplication();
Vector2 mDpi;
unsigned int mLastVSyncTime;
+ ResourcePolicy::DataRetention mDataRetentionPolicy;
};
} // Dali
if( getBitmap )
{
- bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, true);
+ bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD);
bitmapData->GetPackedPixelsProfile()->ReserveBuffer(Pixel::A8, 64, 64);
PixelBuffer* pixelBuffer = bitmapData->GetBuffer();
memset( pixelBuffer, it->character, 64*64 );
characters.insert( it->character );
Integration::GlyphMetrics character = {it->character, Integration::GlyphMetrics::HIGH_QUALITY, 10.0f, 10.0f, 9.0f, 1.0f, 10.0f, it->xPosition, it->yPosition };
- bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, true);
+ bitmapData = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD);
bitmapData->GetPackedPixelsProfile()->ReserveBuffer(Pixel::A8, 64, 64);
PixelBuffer* pixelBuffer = bitmapData->GetBuffer();
memset( pixelBuffer, it->character, 64*64 );
Integration::BitmapPtr TestPlatformAbstraction::GetGlyphImage( const std::string& fontFamily, const std::string& fontStyle, float fontSize, uint32_t character ) const
{
- Integration::BitmapPtr image = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, true );
+ Integration::BitmapPtr image = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
image->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 1, 1 );
mTrace.PushCall("GetGlyphImage", "");
DALI_TEST_CHECK( pushButton2 );
- pushButton2 = NULL;
+ pushButton2.Reset();
// Test down cast
Handle handleButton;
#include <dali-toolkit/internal/builder/builder-get-is.inl.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
{
-namespace Internal DALI_INTERNAL
+namespace Internal
{
/*
#include <dali-toolkit/internal/builder/tree-node-manipulator.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
{
-namespace Internal DALI_INTERNAL
+namespace Internal
{
/*
#include <dali/public-api/common/dali-common.h>
#include <dali-toolkit/public-api/builder/tree-node.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
{
-namespace Internal DALI_INTERNAL
+namespace Internal
{
typedef std::vector<char> VectorChar;
typedef VectorChar::iterator VectorCharIter;
#include <dali-toolkit/public-api/controls/scrollable/scroll-component.h>
#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
// Forward declarations
-namespace Internal DALI_INTERNAL
+namespace Internal
{
// Forward declarations
#include <dali/public-api/images/frame-buffer-image.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
*/
-class Builder : public BaseHandle
+class DALI_IMPORT_API Builder : public BaseHandle
{
public:
/**
Signal& QuitSignal();
private:
- Builder(Internal::Builder *impl);
+ explicit DALI_INTERNAL Builder(Internal::Builder *impl);
}; // class Builder
#include <dali-toolkit/public-api/builder/tree-node.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/*
* Parses JSON
*/
-class JsonParser : public BaseHandle
+class DALI_IMPORT_API JsonParser : public BaseHandle
{
public:
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* TreeNode does not own its string data which is held by a container eg JsonParser
* Modification operations should be done through a container.
*/
-class TreeNode
+class DALI_IMPORT_API TreeNode
{
public:
/*
/*
* Constructor
*/
- TreeNode();
+ DALI_INTERNAL TreeNode();
// non copyable or assignable
- TreeNode(TreeNode &);
- TreeNode& operator=(const TreeNode&);
+ DALI_INTERNAL TreeNode(TreeNode &);
+ DALI_INTERNAL TreeNode& operator=(const TreeNode&);
const char* mName; ///< The nodes name (if any)
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* All actors added to an alignment are going to be set with the same anchor point and parent origin. And, if the scaling property is set to a value
* different than ScaleNone, constraints as well.
*/
-class Alignment : public Control
+class DALI_IMPORT_API Alignment : public Control
{
public:
/**
*
* @param[in] implementation The Control implementation.
*/
- Alignment( Internal::Alignment& implementation );
+ DALI_INTERNAL Alignment( Internal::Alignment& implementation );
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- Alignment( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Alignment( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
-namespace Internal DALI_INTERNAL
-{
-class CustomActor;
-}
-
namespace Toolkit
{
*
* When the \e dimmed property is set to \e true, no signal is emitted.
*/
-class Button : public Control
+class DALI_IMPORT_API Button : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- Button( Internal::Button& implementation );
+ DALI_INTERNAL Button( Internal::Button& implementation );
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- Button( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL Button( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/buttons/button.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* CheckBoxButton doesn't have a text. However, a Dali::Toolkit::TableView with a Dali::TextActor or a Dali::Toolkit::TextView
* and a CheckBoxButton could be used instead.
*/
-class CheckBoxButton : public Button
+class DALI_IMPORT_API CheckBoxButton : public Button
{
public:
//Action Names
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- CheckBoxButton( Internal::CheckBoxButton& implementation );
+ DALI_INTERNAL CheckBoxButton( Internal::CheckBoxButton& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- CheckBoxButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL CheckBoxButton( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include "button.h"
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* Is not mandatory set all images. A button could be defined only by setting its \e background image or by setting its \e background and \e pressed images.
*/
-class PushButton : public Button
+class DALI_IMPORT_API PushButton : public Button
{
public:
*
* @param[in] implementation The Control implementation.
*/
- PushButton( Internal::PushButton& implementation );
+ DALI_INTERNAL PushButton( Internal::PushButton& implementation );
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- PushButton( Dali::Internal::CustomActor* internal );
+ DALI_INTERNAL PushButton( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include "button.h"
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* A Button::ClickedSignal() is emitted when the RadioButton change its state to \e active or \e inactive.
*/
-class RadioButton: public Button
+class DALI_IMPORT_API RadioButton: public Button
{
public:
*
* @param[in] implementation The Control implementation.
*/
- RadioButton(Internal::RadioButton& implementation);
+ DALI_INTERNAL RadioButton(Internal::RadioButton& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- RadioButton(Dali::Internal::CustomActor* internal);
+ DALI_INTERNAL RadioButton(Dali::Internal::CustomActor* internal);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param[in] styleManager The StyleManager Object
* @param[in] change Information denoting what has changed.
*/
- void DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change );
+ DALI_INTERNAL void DoStyleChange( Toolkit::StyleManager styleManager, StyleChange change );
protected: // Construction
* @param[in,out] container The container that holds actors that are fed back into the
* RelayoutController algorithm.
*/
- void NegotiateSize( Vector2 size, ActorSizeContainer& container );
+ DALI_INTERNAL void NegotiateSize( Vector2 size, ActorSizeContainer& container );
private:
* @param[in,out] container The control should add actors to this container that it is not able
* to allocate a size for.
*/
- void Relayout( Vector2 size, ActorSizeContainer& container );
+ DALI_INTERNAL void Relayout( Vector2 size, ActorSizeContainer& container );
/**
* @brief Used by the KeyInputFocusManager to emit key event signals.
* @param[in] event The key event.
* @return True if the event was consumed.
*/
- bool EmitKeyEventSignal(const KeyEvent& event);
+ DALI_INTERNAL bool EmitKeyEventSignal(const KeyEvent& event);
private:
// Undefined
- Control(const Control&);
- Control& operator=(const Control&);
+ DALI_INTERNAL Control(const Control&);
+ DALI_INTERNAL Control& operator=(const Control&);
class Impl;
Impl* mImpl;
#include <dali/public-api/events/tap-gesture-detector.h>
#include <dali/public-api/images/image.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* The implementation of the control must be supplied; see Internal::Control for more details.
* @see Internal::Control
*/
-class Control : public CustomActor
+class DALI_IMPORT_API Control : public CustomActor
{
public:
*/
KeyEventSignalV2& KeyEventSignal();
-public: // Not intended for application developers
+public: // Intended for control developers (used implicitly)
/**
* @brief Create an initialised Control.
* @see DownCast(BaseHandle)
*/
template<typename T, typename I>
- static T DownCast( BaseHandle handle )
+ DALI_INTERNAL static T DownCast( BaseHandle handle )
{
T result;
* @param[in] internal Pointer to the Internal::CustomActor
*/
template<typename I>
- void VerifyCustomActorPointer(Dali::Internal::CustomActor* internal)
+ DALI_INTERNAL void VerifyCustomActorPointer(Dali::Internal::CustomActor* internal)
{
// Can have a NULL pointer so we only need to check if the internal implementation is our class
// when there is a value.
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/buttons/check-box-button.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param[in] dimmedBackgroundImagePath Image path to be shown as button dimmed background.
* @param[in] dimmedCheckedImagePath Image path to be shown as dimmed checked button.
*/
-CheckBoxButton CreateCheckBoxButton( const std::string& backgroundImagePath, const std::string& checkedImagePath, const std::string& dimmedBackgroundImagePath, const std::string& dimmedCheckedImagePath );
+DALI_IMPORT_API CheckBoxButton CreateCheckBoxButton( const std::string& backgroundImagePath, const std::string& checkedImagePath, const std::string& dimmedBackgroundImagePath, const std::string& dimmedCheckedImagePath );
/**
* Creates a check box button with the given images.
* @param[in] dimmedBackgroundImageActor Image to be shown as button dimmed background.
* @param[in] dimmedCheckedImagActor Image to be shown as dimmed checked button.
*/
-CheckBoxButton CreateCheckBoxButton( Actor backgroundImageActor, Actor checkedImageActor, Actor dimmedBackgroundImageActor, Actor dimmedCheckedImagActor );
+DALI_IMPORT_API CheckBoxButton CreateCheckBoxButton( Actor backgroundImageActor, Actor checkedImageActor, Actor dimmedBackgroundImageActor, Actor dimmedCheckedImagActor );
/**
* Creates a check box button with the given background and checked images.
* @param[in] backgroundImagePath Image path to be shown as button background.
* @param[in] checkedImagePath Image path to be shown as checked button.
*/
-CheckBoxButton CreateCheckBoxButton( const std::string& backgroundImagePath, const std::string& checkedImagePath );
+DALI_IMPORT_API CheckBoxButton CreateCheckBoxButton( const std::string& backgroundImagePath, const std::string& checkedImagePath );
/**
* Creates a check box button with the given background and checked images.
* @param[in] backgroundImageActor Image to be shown as button background.
* @param[in] checkedImageActor Image to be shown as checked button.
*/
-CheckBoxButton CreateCheckBoxButton( Actor backgroundImageActor, Actor checkedImageActor );
+DALI_IMPORT_API CheckBoxButton CreateCheckBoxButton( Actor backgroundImageActor, Actor checkedImageActor );
+
} // namespace Toolkit
} // namespace Dali
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/buttons/push-button.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param[in] dimmedBackgroundImagePath Image path to be shown as button background when the button is dimmed.
* @return A handle to the new push button
*/
-PushButton CreatePushButton( const std::string& releasedImagePath, const std::string& pressedImagePath, const std::string& backgroundImagePath,
+DALI_IMPORT_API PushButton CreatePushButton( const std::string& releasedImagePath, const std::string& pressedImagePath, const std::string& backgroundImagePath,
const std::string& dimmedReleasedImagePath, const std::string& dimmedBackgroundImagePath );
/**
* @param[in] dimmedBackgroundImageActor Image to be shown as button background when the button is dimmed.
* @return A handle to the new pushbutton
*/
-PushButton CreatePushButton( Actor releasedImageActor, Actor pressedImageActor, Actor backgroundImageActor,
+DALI_IMPORT_API PushButton CreatePushButton( Actor releasedImageActor, Actor pressedImageActor, Actor backgroundImageActor,
Actor dimmedReleasedImageActor, Actor dimmedBackgroundImageActor );
/**
* @param[in] backgroundImagePath Image path to be shown as button background.
* @return a handle to the new push button
*/
-PushButton CreatePushButton( const std::string& backgroundImagePath );
+DALI_IMPORT_API PushButton CreatePushButton( const std::string& backgroundImagePath );
/**
* @brief Creates a push button with the given background image.
* @param[in] backgroundImageActor Image to be shown as button background.
* @return a handle to the new push button
*/
-PushButton CreatePushButton( Actor backgroundImageActor );
+DALI_IMPORT_API PushButton CreatePushButton( Actor backgroundImageActor );
} // namespace Toolkit
#include <dali/public-api/math/vector4.h>
#include <dali/public-api/actors/image-actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param[in] borderSize The size for the ImageActor's border. By default, the value is set to 1 pixel. It supports under 10 pixel for clear result of gl blend
* @return a handle to the new ImageActor
*/
-ImageActor CreateSolidColorActor( const Vector4& color, bool border = false, const Vector4& borderColor = Color::WHITE, const unsigned int borderSize = 1 );
-
+DALI_IMPORT_API ImageActor CreateSolidColorActor( const Vector4& color, bool border = false, const Vector4& borderColor = Color::WHITE, const unsigned int borderSize = 1 );
} // namespace Toolkit
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/text-view/text-view.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* A popup can use various custom transition effects, e.g.
* Alpha fade, Scaling transition, position/rotation, shader effects.
*/
-class Popup : public Control
+class DALI_IMPORT_API Popup : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- Popup(Internal::Popup& implementation);
+ DALI_INTERNAL Popup(Internal::Popup& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- Popup( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Popup( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-component.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* ScrollBar is a UI component that can be added to the scrollable controls
* indicating the current scroll position of the scrollable content.
*/
-class ScrollBar : public ScrollComponent
+class DALI_IMPORT_API ScrollBar : public ScrollComponent
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- ScrollBar( Internal::ScrollBar& implementation );
+ DALI_INTERNAL ScrollBar( Internal::ScrollBar& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- ScrollBar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ScrollBar( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* An ItemView layout which arranges items in a album.
*/
-class AlbumLayout : public ItemLayout
+class DALI_IMPORT_API AlbumLayout : public ItemLayout
{
public:
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* This layout arranges items in a grid, which scrolls along the Z-Axis.
*/
-class DepthLayout : public ItemLayout
+class DALI_IMPORT_API DepthLayout : public ItemLayout
{
public:
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief An ItemView layout which arranges items in a grid.
*/
-class GridLayout : public ItemLayout
+class DALI_IMPORT_API GridLayout : public ItemLayout
{
public:
// EXTERNAL INCLUDES
#include <dali/public-api/actors/actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief Virtual destructor.
*/
- virtual ~ItemFactory() = 0;
+ DALI_EXPORT_API virtual ~ItemFactory() = 0;
/**
* @brief Query the number of items available from the factory.
#include <dali-toolkit/public-api/enums.h>
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief Virtual destructor.
*/
- virtual ~ItemLayout();
+ DALI_IMPORT_API virtual ~ItemLayout();
/**
* @brief Set the orientation of the layout.
*
* @param[in] orientation The orientation of the layout.
*/
- void SetOrientation(ControlOrientation::Type orientation);
+ DALI_IMPORT_API void SetOrientation(ControlOrientation::Type orientation);
/**
* @brief Query the orientation of the layout.
*
* @return the orientation of the layout.
*/
- ControlOrientation::Type GetOrientation() const;
+ DALI_IMPORT_API ControlOrientation::Type GetOrientation() const;
/**
* @brief Query the minimum valid layout position; this is a negative value.
* @param[in] layoutSize the current size of the item view instance
* @return The layout position
*/
- virtual float GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize);
+ DALI_IMPORT_API virtual float GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize);
/**
* @brief Query the number of items that should be reserved, for scrolling purposes.
*
* @param[out] scrollHint Vector2 describing how x and y scroll values should be used for x-axis scrolling
*/
- virtual void GetXAxisScrollHint(Vector2& scrollHint) const;
+ DALI_IMPORT_API virtual void GetXAxisScrollHint(Vector2& scrollHint) const;
/**
* @brief Tells scroll components how to interpolate our logical scroll position as a screen x/y direction.
*
* @param[out] scrollHint Vector2 describing how x and y scroll values should be used for y-axis scrolling
*/
- virtual void GetYAxisScrollHint(Vector2& scrollHint) const;
+ DALI_IMPORT_API virtual void GetYAxisScrollHint(Vector2& scrollHint) const;
/**
* @brief Query the scroll speed factor of the layout while dragging.
* @param[in] loopEnabled Whether the KeyboardFocusManager is set to wrap around between first and last item
* @return The next item ID.
*/
- virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
+ DALI_IMPORT_API virtual int GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled);
/**
* @brief Query the flick speed factor of the layout while swipping.
*
* @return The scroll speed factor of the layout.
*/
- virtual float GetFlickSpeedFactor() const;
+ DALI_IMPORT_API virtual float GetFlickSpeedFactor() const;
/*
* @brief Applies constraints defined by the layout to an actor.
* @param[in] scrollPositionObject The object which provides the layout position property.
* @param[in] itemViewActor The item view instance which requests the application of constraints.
*/
- virtual void ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Constrainable scrollPositionObject, const Actor& itemViewActor );
+ DALI_IMPORT_API virtual void ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Constrainable scrollPositionObject, const Actor& itemViewActor );
/**
* @brief Gets the position of a given item
* @param[in] layoutSize the current size of the item view instance
* @return The item position (x,y,z)
*/
- virtual Vector3 GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const;
+ DALI_IMPORT_API virtual Vector3 GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const;
/**
* @brief Set the alpha function used when applying constraints
*
* @param[in] func The alpha function to use.
*/
- void SetAlphaFunction(AlphaFunction func);
+ DALI_IMPORT_API void SetAlphaFunction(AlphaFunction func);
/**
* @brief Retrieve the alpha function used when applying constraints
*
* @return The alpha function.
*/
- AlphaFunction GetAlphaFunction() const;
+ DALI_IMPORT_API AlphaFunction GetAlphaFunction() const;
protected:
/**
* @brief Create a new ItemLayout; Only derived versions are instantiatable.
*/
- ItemLayout();
+ DALI_IMPORT_API ItemLayout();
protected:
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/common/vector-wrapper.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Multiple ItemLayouts may be provided, to determine the logical position of each item a layout.
* Actors are provided from an external ItemFactory, to display the currently visible items.
*/
-class ItemView : public Scrollable
+class DALI_IMPORT_API ItemView : public Scrollable
{
public:
*
* @param[in] implementation The Control implementation.
*/
- ItemView(Internal::ItemView& implementation);
+ DALI_INTERNAL ItemView(Internal::ItemView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- ItemView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ItemView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
{
/**
* An ItemView layout which arranges items in navigation mode.
*/
-class NavigationLayout: public ItemLayout
+class DALI_IMPORT_API NavigationLayout: public ItemLayout
{
public:
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* An ItemView layout which arranges items in a roll.
*/
-class RollLayout : public ItemLayout
+class DALI_IMPORT_API RollLayout : public ItemLayout
{
public:
#include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* An ItemView layout which arranges items in a spiral.
*/
-class SpiralLayout : public ItemLayout
+class DALI_IMPORT_API SpiralLayout : public ItemLayout
{
public:
* Base class for scroll component implementations.
* Scroll-components such as scroll bars, indicators etc. are connected to scrollable containers via ScrollConnector.
*/
-class ScrollComponentImpl : public Internal::Control
+class DALI_IMPORT_API ScrollComponentImpl : public Internal::Control
{
public:
private:
// Undefined
- ScrollComponentImpl(const ScrollComponentImpl&);
+ DALI_INTERNAL ScrollComponentImpl(const ScrollComponentImpl&);
// Undefined
- ScrollComponentImpl& operator=(const ScrollComponentImpl& rhs);
+ DALI_INTERNAL ScrollComponentImpl& operator=(const ScrollComponentImpl& rhs);
protected:
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Base class for scroll component handles.
* Scroll-components such as scroll bars, indicators etc. are connected to scrollable containers via ScrollConnector.
*/
-class ScrollComponent : public Control
+class DALI_IMPORT_API ScrollComponent : public Control
{
public:
* Creates a handle using the implementation.
* @param[in] implementation The Control implementation.
*/
- ScrollComponent( ScrollComponentImpl& implementation );
+ DALI_INTERNAL ScrollComponent( ScrollComponentImpl& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- ScrollComponent( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ScrollComponent( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/object/constrainable.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* -1 to 1, where -1 shows an attempt the scroll beyond the minimum limit, and 1 shows an attempt the scroll beyond the maximum limit.
* Zero indicates normal scrolling i.e. when overshoot indicators should be hidden.
*/
-class ScrollConnector : public BaseHandle
+class DALI_IMPORT_API ScrollConnector : public BaseHandle
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] impl The Control implementation.
*/
- ScrollConnector( Internal::ScrollConnector* impl );
+ explicit DALI_INTERNAL ScrollConnector( Internal::ScrollConnector* impl );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Notes:
* * Assumes Actor's AnchorPoint = AnchorPoint::CENTER
*/
-class ScrollViewCarouselEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewCarouselEffect : public ScrollViewEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewCarouselEffect(Internal::ScrollViewCarouselEffect *impl);
+ explicit DALI_INTERNAL ScrollViewCarouselEffect(Internal::ScrollViewCarouselEffect *impl);
};
// INTERNAL INCLUDES
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
*
* Moves an Actor in accordance to scroll position.
*/
-Vector3 MoveActorConstraint(const Vector3& current,
- const PropertyInput& scrollPositionProperty);
+DALI_IMPORT_API Vector3 MoveActorConstraint(const Vector3& current,
+ const PropertyInput& scrollPositionProperty);
/**
* Wrap Actor constraint.
*
* Wraps an Actors position in accordance to min/max bounds of domain.
*/
-Vector3 WrapActorConstraint(const Vector3& current,
- const PropertyInput& actorScaleProperty,
- const PropertyInput& actorAnchorPointProperty,
- const PropertyInput& actorSizeProperty,
- const PropertyInput& scrollPositionMin,
- const PropertyInput& scrollPositionMax,
- const PropertyInput& scrollWrap);
+DALI_IMPORT_API Vector3 WrapActorConstraint(const Vector3& current,
+ const PropertyInput& actorScaleProperty,
+ const PropertyInput& actorAnchorPointProperty,
+ const PropertyInput& actorSizeProperty,
+ const PropertyInput& scrollPositionMin,
+ const PropertyInput& scrollPositionMax,
+ const PropertyInput& scrollWrap);
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewCubeEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewCubeEffect : public ScrollViewEffect
{
public:
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewCubeEffect(Internal::ScrollViewCubeEffect *impl);
+ explicit DALI_INTERNAL ScrollViewCubeEffect(Internal::ScrollViewCubeEffect *impl);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewCustomEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewCustomEffect : public ScrollViewEffect
{
public:
/**
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewCustomEffect( Internal::ScrollViewCustomEffect *impl );
+ explicit DALI_INTERNAL ScrollViewCustomEffect( Internal::ScrollViewCustomEffect *impl );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewDepthEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewDepthEffect : public ScrollViewEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewDepthEffect(Internal::ScrollViewDepthEffect *impl);
+ explicit DALI_INTERNAL ScrollViewDepthEffect(Internal::ScrollViewDepthEffect *impl);
};
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct Vector2;
* constraints that are applied to ShaderEffects or Actors using these
* properties as inputs.
*/
-class ScrollViewEffect : public Dali::BaseHandle
+class DALI_IMPORT_API ScrollViewEffect : public Dali::BaseHandle
{
public:
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewEffect(Internal::ScrollViewEffect *impl);
+ explicit DALI_INTERNAL ScrollViewEffect(Internal::ScrollViewEffect *impl);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewPageCarouselEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewPageCarouselEffect : public ScrollViewEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewPageCarouselEffect( Internal::ScrollViewPageCarouselEffect *impl );
+ explicit DALI_INTERNAL ScrollViewPageCarouselEffect( Internal::ScrollViewPageCarouselEffect *impl );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewPageCubeEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewPageCubeEffect : public ScrollViewEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewPageCubeEffect( Internal::ScrollViewPageCubeEffect *impl );
+ explicit DALI_INTERNAL ScrollViewPageCubeEffect( Internal::ScrollViewPageCubeEffect *impl );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
* Automatic operation:
* not implemented.
*/
-class ScrollViewPageSpiralEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewPageSpiralEffect : public ScrollViewEffect
{
public:
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewPageSpiralEffect( Internal::ScrollViewPageSpiralEffect *impl );
+ explicit DALI_INTERNAL ScrollViewPageSpiralEffect( Internal::ScrollViewPageSpiralEffect *impl );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
/**
* @brief ScrollView effect that uses slides for transitioning pages.
*/
-class ScrollViewSlideEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewSlideEffect : public ScrollViewEffect
{
public:
static const std::string EFFECT_TIME; ///< Effect time property name
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewSlideEffect(Internal::ScrollViewSlideEffect *impl);
+ explicit DALI_INTERNAL ScrollViewSlideEffect(Internal::ScrollViewSlideEffect *impl);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
/**
* @brief ScrollView effect that twists pages onto screen when transitioning.
*/
-class ScrollViewTwistEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewTwistEffect : public ScrollViewEffect
{
public:
*
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewTwistEffect(Internal::ScrollViewTwistEffect *impl);
+ explicit DALI_INTERNAL ScrollViewTwistEffect(Internal::ScrollViewTwistEffect *impl);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scroll-view/scroll-view-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Using this effect, a %wobble% property is produced which swings
* towards the origin in accordance to how the user pans the ScrollView.
*/
-class ScrollViewWobbleEffect : public ScrollViewEffect
+class DALI_IMPORT_API ScrollViewWobbleEffect : public ScrollViewEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- ScrollViewWobbleEffect(Internal::ScrollViewWobbleEffect *impl);
+ explicit DALI_INTERNAL ScrollViewWobbleEffect(Internal::ScrollViewWobbleEffect *impl);
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief Used for specifying minimum/maximum extents of a ruler.
*/
-class RulerDomain
+class DALI_IMPORT_API RulerDomain
{
public:
* It can specify whether they are traversable, where their snap
* points are and their domain.
*/
-class Ruler : public RefObject
+class DALI_IMPORT_API Ruler : public RefObject
{
public:
/// @brief The type of the ruler
/**
* @brief Concrete implementation of Ruler that has no snapping and has one single page.
*/
-class DefaultRuler : public Ruler
+class DALI_IMPORT_API DefaultRuler : public Ruler
{
public:
/**
/**
* @brief Concrete implementation of Ruler that has fixed snapping.
*/
-class FixedRuler : public Ruler
+class DALI_IMPORT_API FixedRuler : public Ruler
{
public:
/**
* @brief ScrollView contains actors that can be scrolled manually (via touch)
* or automatically.
*/
-class ScrollView : public Scrollable
+class DALI_IMPORT_API ScrollView : public Scrollable
{
public:
/// Page effect types
*
* @param[in] implementation The Control implementation.
*/
- ScrollView(Internal::ScrollView& implementation);
+ DALI_INTERNAL ScrollView(Internal::ScrollView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- ScrollView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ScrollView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* Scrollables such as ScrollView and ItemView can be derived from this class.
*/
-class Scrollable : public Control
+class DALI_IMPORT_API Scrollable : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- Scrollable(Internal::Scrollable& implementation);
+ DALI_INTERNAL Scrollable(Internal::Scrollable& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- Scrollable( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Scrollable( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* z position and depth are left intact so that 3D model actors can also be laid out
* in a grid without loosing their depth scaling.
*/
-class TableView : public Control
+class DALI_IMPORT_API TableView : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- TableView(Internal::TableView& implementation);
+ DALI_INTERNAL TableView(Internal::TableView& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- TableView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TableView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/text-view/text-view.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Characters can be removed from the end of the string until it is empty. A maximum length of displayed string
* can be set.
*/
-class TextInput : public Control
+class DALI_IMPORT_API TextInput : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- TextInput(Internal::TextInput& implementation);
+ DALI_INTERNAL TextInput(Internal::TextInput& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- TextInput(Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextInput(Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
#include <dali-toolkit/public-api/controls/alignment/alignment.h>
#include <dali-toolkit/public-api/markup-processor/markup-processor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* See the \link text-view Text View \endlink page of the Programming Guide for more details and examples.
*/
-class TextView : public Control
+class DALI_IMPORT_API TextView : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- TextView( Internal::TextView& implementation );
+ DALI_INTERNAL TextView( Internal::TextView& implementation );
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- TextView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL TextView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @param[in] orientation The orientation.
* @return True if the orientation is vertical.
*/
-bool IsVertical(ControlOrientation::Type orientation);
+DALI_IMPORT_API bool IsVertical(ControlOrientation::Type orientation);
/**
* @brief Query whether an orientation is horizontal.
* @param[in] orientation The orientation.
* @return True if the orientation is horizontal.
*/
-bool IsHorizontal(ControlOrientation::Type orientation);
+DALI_IMPORT_API bool IsHorizontal(ControlOrientation::Type orientation);
} // namespace Toolkit
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/image-actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* focused actor and emits a signal when the focus is changed.
*/
-class FocusManager : public BaseHandle
+class DALI_IMPORT_API FocusManager : public BaseHandle
{
public:
// Signal Names
private:
- FocusManager(Internal::FocusManager *impl);
+ explicit DALI_INTERNAL FocusManager(Internal::FocusManager *impl);
}; // class FocusManager
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* highlight for the focused actor and emits a signal when the focus
* is changed.
*/
-class KeyboardFocusManager : public BaseHandle
+class DALI_IMPORT_API KeyboardFocusManager : public BaseHandle
{
public:
//Signal Names
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* the next control in the stack. If none of the controls in the stack consume the key event then
* UnhandledKeyEventSignal() is emitted.
*/
-
- class KeyInputFocusManager : public BaseHandle
- {
- public:
- //Signal Names
+class DALI_IMPORT_API KeyInputFocusManager : public BaseHandle
+{
+public:
+ // Signal Names
static const char* const SIGNAL_KEY_INPUT_FOCUS_CHANGED;
static const char* const SIGNAL_UNHANDLED_KEY_EVENT;
// Unhandled Key Event
typedef SignalV2< void (const KeyEvent&) > UnhandledKeyEventSignalV2;
- public:
+public:
/**
* Create a KeyInputFocusManager handle; this can be initialised with KeyInputFocusManager::Get()
*/
bool IsKeyboardListener(Control control);
- public: // Signals
+public: // Signals
/**
* This signal is emitted when the key input focus control changes.
private:
- KeyInputFocusManager(Internal::KeyInputFocusManager *impl);
+ explicit DALI_INTERNAL KeyInputFocusManager(Internal::KeyInputFocusManager *impl);
}; // class KeyInputFocusManager
#include <dali/public-api/text/text.h>
#include <dali/public-api/text/text-style.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param [out] styledTextArray A text array split in characters, each one with its style.
* @param [in] scanForMarkup If true will check to see string contains markup, else assume not
*/
-void GetStyledTextArray( const std::string& markupString, StyledTextArray& styledTextArray, bool scanForMarkup );
+DALI_IMPORT_API void GetStyledTextArray( const std::string& markupString, StyledTextArray& styledTextArray, bool scanForMarkup );
/**
* @brief Creates a plain string from a text array (thus stripping the style meta).
* @param [in] styledTextArray A text array split in characters, each one with its style.
* @param [out] plainString A string without style.
*/
-void GetPlainString( const StyledTextArray& styledTextArray, std::string& plainString );
+DALI_IMPORT_API void GetPlainString( const StyledTextArray& styledTextArray, std::string& plainString );
/**
* @brief Creates a markup string from a text array with its style.
* @param [in] styledTextArray A text array split in characters, each one with its style.
* @param [out] markupString A string with style.
*/
-void GetMarkupString( const StyledTextArray& styledTextArray, std::string& markupString );
+DALI_IMPORT_API void GetMarkupString( const StyledTextArray& styledTextArray, std::string& markupString );
/**
* @brief Sets a text style to the given text.
* @param[in] style The given style
* @param[in] mask The bit mask.
*/
-void SetTextStyle( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask = TextStyle::ALL );
+DALI_IMPORT_API void SetTextStyle( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask = TextStyle::ALL );
/**
* @brief Sets a text style to the given text.
* @param[in] style The given style.
* @param[in] mask The bit mask.
*/
-void SetTextStyle( const Text& text, StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask = TextStyle::ALL );
+DALI_IMPORT_API void SetTextStyle( const Text& text, StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask = TextStyle::ALL );
/**
* @brief Sets a text style to a range of characters of the given text.
* @param[in] end The last character of the range.
* @note It will assert if begin or end are out of range, or if begin > end.
*/
-void SetTextStyleToRange( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask, std::size_t begin, std::size_t end );
+DALI_IMPORT_API void SetTextStyleToRange( StyledTextArray& styledTextArray, const TextStyle& style, TextStyle::Mask mask, std::size_t begin, std::size_t end );
} // namespace MarkupProcessor
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* 1.f, AlphaFunctions::Bounce );
* animation.Play();
*/
-class BouncingEffect : public ShaderEffect
+class DALI_IMPORT_API BouncingEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- BouncingEffect( ShaderEffect handle );
+ DALI_INTERNAL BouncingEffect( ShaderEffect handle );
};
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief DissolveEffect is a custom shader effect to achieve Dissolve effects in Image actors.
*/
-class DissolveEffect : public ShaderEffect
+class DALI_IMPORT_API DissolveEffect : public ShaderEffect
{
public:
const std::string& GetDistortionPropertyName() const;
private: // Not intended for application developers
- DissolveEffect(ShaderEffect handle);
+ DALI_INTERNAL DissolveEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief ImageRegionEffect is a custom shader effect to show only a region of an Image actor.
*/
-class ImageRegionEffect : public ShaderEffect
+class DALI_IMPORT_API ImageRegionEffect : public ShaderEffect
{
public:
const std::string& GetBottomRightPropertyName() const;
private: // Not intended for application developers
- ImageRegionEffect(ShaderEffect handle);
+ DALI_INTERNAL ImageRegionEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief IrisEffect is a custom shader effect to achieve iris effects in Image actors
*/
-class IrisEffect : public ShaderEffect
+class DALI_IMPORT_API IrisEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- IrisEffect(ShaderEffect handle);
+ DALI_INTERNAL IrisEffect(ShaderEffect handle);
};
}
#include <dali/public-api/images/image.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/actors/image-actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* @param [in] actor The actor which needs the effect. To remove the effect call actor.RemoveShaderEffect().
* @param [in] maskImage The path to a file containing the mask. The center pixels of the mask will be stretched.
*/
-void Apply( ImageActor actor, const std::string& maskImage );
+DALI_IMPORT_API void Apply( ImageActor actor, const std::string& maskImage );
/**
* @brief Apply the mask effect to an ImageActor.
* @param [in] maskImage The path to a file containing the mask.
* @param [in] maskBorder Specifies the part of the mask image that will be stretched (left, top, right, bottom).
*/
-void Apply( ImageActor actor, const std::string& maskImage, const Vector4& maskBorder );
+DALI_IMPORT_API void Apply( ImageActor actor, const std::string& maskImage, const Vector4& maskBorder );
} // namespace NinePatchMaskEffect
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* display the pages visually consistent with its turning state,
* please set the uniforms with the same values as the PageTurnEffect.
**/
-class PageTurnBookSpineEffect : public ShaderEffect
+class DALI_IMPORT_API PageTurnBookSpineEffect : public ShaderEffect
{
public:
/**
private:// Helper for New()
- PageTurnBookSpineEffect( ShaderEffect handle );
+ DALI_INTERNAL PageTurnBookSpineEffect( ShaderEffect handle );
}; // End of PageTurnBookSpineEffect class
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* animation[mAnimationIndex].Play(); \n
*/
-class PageTurnEffect : public ShaderEffect
+class DALI_IMPORT_API PageTurnEffect : public ShaderEffect
{
public:
/**
public: // Not intended for application developers
- PageTurnEffect( ShaderEffect handle, Internal::PageTurnEffect* shaderExtension );
+ DALI_INTERNAL PageTurnEffect( ShaderEffect handle, Internal::PageTurnEffect* shaderExtension );
}; //end of PageTurnEffect class
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief RippleEffect is a custom shader effect to achieve ripple effects on Image actors.
*/
-class RippleEffect : public ShaderEffect
+class DALI_IMPORT_API RippleEffect : public ShaderEffect
{
public:
const std::string& GetTimePropertyName() const;
private:
- RippleEffect(ShaderEffect handle);
+ DALI_INTERNAL RippleEffect(ShaderEffect handle);
};
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief Ripple2DEffect is a custom shader effect to achieve 2d ripple effects on Image actors.
*/
-class Ripple2DEffect : public ShaderEffect
+class DALI_IMPORT_API Ripple2DEffect : public ShaderEffect
{
public:
const std::string& GetTimePropertyName() const;
private:
- Ripple2DEffect(ShaderEffect handle);
+ DALI_INTERNAL Ripple2DEffect(ShaderEffect handle);
};
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* @brief SwirlEffect is a custom shader effect to achieve swirl effects in Image actors.
*/
-class SwirlEffect : public ShaderEffect
+class DALI_IMPORT_API SwirlEffect : public ShaderEffect
{
public:
const std::string& GetRadiusPropertyName() const;
private: // Not intended for application developers
- SwirlEffect(ShaderEffect handle);
+ DALI_INTERNAL SwirlEffect(ShaderEffect handle);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Internal::Control can be configured to register for the signals that are required from StyleManager,
* such as theme change.
*/
-class StyleManager : public BaseHandle
+class DALI_IMPORT_API StyleManager : public BaseHandle
{
public:
mMovementArea( movementArea ),
mShapeImage( shapeImage ),
mTotalNumOfBubble( maximumNumberOfBubble ),
+ mRenderTaskRunning(false),
mBubbleSizeRange( bubbleSizeRange ),
mCurrentUniform( 0 ),
mDensity( 5 )
// Create a cameraActor for the off screen render task.
mCameraActor = CameraActor::New(mMovementArea);
mCameraActor.SetParentOrigin(ParentOrigin::CENTER);
- Stage::GetCurrent().Add(mCameraActor);
+
+ Stage stage = Stage::GetCurrent();
+
+ stage.Add(mCameraActor);
+ stage.ContextRegainedSignal().Connect(this, &BubbleEmitter::OnContextRegained);
}
Actor BubbleEmitter::GetRootActor()
void BubbleEmitter::SetBackground( Image bgImage, const Vector3& hsvDelta )
{
+ mBackgroundImage = bgImage;
+ mHSVDelta = hsvDelta;
+
ImageActor sourceActor = ImageActor::New( bgImage );
sourceActor.SetSize( mMovementArea );
sourceActor.SetParentOrigin(ParentOrigin::CENTER);
task.GetCameraActor().SetInvertYAxis(true);
task.SetTargetFrameBuffer( mEffectImage );
task.FinishedSignal().Connect(this, &BubbleEmitter::OnRenderFinished);
+ mRenderTaskRunning = true;
}
void BubbleEmitter::SetShapeImage( Image shapeImage )
// clear the resources created for the off screen rendering
void BubbleEmitter::OnRenderFinished(RenderTask& source)
{
+ mRenderTaskRunning = false;
Actor sourceActor = source.GetSourceActor();
if( sourceActor )
{
renderable.RemoveShaderEffect();
}
}
- Stage::GetCurrent().Remove(sourceActor);
- Stage::GetCurrent().GetRenderTaskList().RemoveTask(source);
+
+ Stage stage = Stage::GetCurrent();
+ stage.Remove(sourceActor);
+ stage.GetRenderTaskList().RemoveTask(source);
+}
+
+void BubbleEmitter::OnContextRegained()
+{
+ // Context was lost, so the framebuffer has been destroyed. Re-create render task
+ // and trigger re-draw if not already running
+ if( ! mRenderTaskRunning )
+ {
+ SetBackground( mBackgroundImage, mHSVDelta );
+ }
}
void BubbleEmitter::SetBlendMode( bool enable )
void OnRenderFinished(RenderTask& source);
/**
+ * Callback function from Stage to tell us if the context has been regained.
+ */
+ void OnContextRegained();
+
+ /**
* Generate the material object which is attached to the meshActor to describe its color, texture, texture mapping mode etc.
*/
void GenMaterial();
unsigned int mNumBubblePerShader; ///< How many bubbles for each BubbleEffect shader.
unsigned int mNumShader; ///< How many BubbleEffect shaders are used.
unsigned int mTotalNumOfBubble; ///< mNumBubblePerShader*mNumShader.
+ bool mRenderTaskRunning; ///< If the background render task is currently running
+
Vector2 mBubbleSizeRange; ///< The bubble size range.
std::vector<Mesh> mMesh; ///< The mesh vector, each mesh is used to create a meshActor which applies a BubbleEffect.
unsigned int mCurrentUniform; ///< Keep track of the uniform index for the newly emitted bubble
+ Vector3 mHSVDelta; ///< The HSV difference used to adjust the background image color.
+ Image mBackgroundImage; ///< The original background image
FrameBufferImage mEffectImage; ///< The image stores the adjusted color of the background image.The bubbles pick color from this image.
CameraActor mCameraActor; ///< The render task views the scene from the perspective of this actor.
#include <dali-toolkit/public-api/controls/control.h>
#include <dali-toolkit/public-api/controls/gaussian-blur-view/gaussian-blur-view.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Stage::GetCurrent().Remove(bloomView);\n
* bloomView.Deactivate();\n
*/
-class BloomView : public Control
+class DALI_IMPORT_API BloomView : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The UI Control implementation.
*/
- BloomView( Internal::BloomView& implementation );
+ DALI_INTERNAL BloomView( Internal::BloomView& implementation );
/**
* Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- BloomView( Dali::Internal::CustomActor* internal );
-
-private:
+ explicit DALI_INTERNAL BloomView( Dali::Internal::CustomActor* internal );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* This is done by applying BubbleEffect to multiple specifically created meshActors.
*/
-class BubbleEmitter : public Control
+class DALI_IMPORT_API BubbleEmitter : public Control
{
public:
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL BubbleEmitter(Dali::Internal::CustomActor* internal);
+ explicit DALI_INTERNAL BubbleEmitter(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/enums.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Actor;
/**
* @brief A ClusterStyle describes the constraints which are imposed on the child actors in the cluster.
*/
-class ClusterStyle : public Dali::BaseHandle
+class DALI_IMPORT_API ClusterStyle : public Dali::BaseHandle
{
public:
*
* @param [in] internal A pointer to a newly allocated Dali resource
*/
- ClusterStyle(Internal::ClusterStyle* internal);
+ explicit DALI_INTERNAL ClusterStyle(Internal::ClusterStyle* internal);
};
/**
* @brief A ClusterStyle describes the constraints, which are imposed on the child actors in the cluster.
*/
-class ClusterStyleStandard : public ClusterStyle
+class DALI_IMPORT_API ClusterStyleStandard : public ClusterStyle
{
public:
*
* @param [in] internal A pointer to a newly allocated Dali resource
*/
- ClusterStyleStandard(Internal::ClusterStyle* internal);
+ explicit DALI_INTERNAL ClusterStyleStandard(Internal::ClusterStyle* internal);
};
/**
* @brief A ClusterStyle describes the constraints, which are imposed on the child actors in the cluster.
*/
-class ClusterStyleRandom : public ClusterStyle
+class DALI_IMPORT_API ClusterStyleRandom : public ClusterStyle
{
public:
*
* @param [in] internal A pointer to a newly allocated Dali resource
*/
- ClusterStyleRandom(Internal::ClusterStyle* internal);
+ explicit DALI_INTERNAL ClusterStyleRandom(Internal::ClusterStyle* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* Cluster is a container of grouped actors positioned in different cluster styles.
*/
-class Cluster : public Control
+class DALI_IMPORT_API Cluster : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- Cluster( Internal::Cluster& implementation );
+ DALI_INTERNAL Cluster( Internal::Cluster& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- Cluster( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Cluster( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* // start effect processing
* effectsView.Enable();
*/
-class EffectsView : public Control
+class DALI_IMPORT_API EffectsView : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- EffectsView( Internal::EffectsView& implementation );
+ DALI_INTERNAL EffectsView( Internal::EffectsView& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- EffectsView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL EffectsView( Dali::Internal::CustomActor* internal );
}; // class EffectsView
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Stage::GetCurrent().Remove(gaussianBlurView);\n
* gaussianBlurView.Deactivate();\n
*/
-class GaussianBlurView : public Control
+class DALI_IMPORT_API GaussianBlurView : public Control
{
public:
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The UI Control implementation.
*/
- GaussianBlurView( Internal::GaussianBlurView& implementation );
+ DALI_INTERNAL GaussianBlurView( Internal::GaussianBlurView& implementation );
/**
* Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- GaussianBlurView( Dali::Internal::CustomActor* internal );
-
-private:
+ DALI_INTERNAL GaussianBlurView( Dali::Internal::CustomActor* internal );
};
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* based on the distance imageView is from mCamera an appropriate, different
* image will be loaded and dispayed.
*/
-class ImageView : public Control
+class DALI_IMPORT_API ImageView : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- ImageView(Internal::ImageView& implementation);
+ DALI_INTERNAL ImageView(Internal::ImageView& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- ImageView(Dali::Internal::CustomActor* internal);
+ explicit DALI_INTERNAL ImageView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* avoided by calling Pause() e.g. when the source & mask positions are not being modified. The Resume() method can then be called
* to continue the masking operation when required.
*/
-class MaskedImageView : public Control
+class DALI_IMPORT_API MaskedImageView : public Control
{
public:
*
* @param[in] implementation The Control implementation.
*/
- MaskedImageView(Internal::MaskedImageView& implementation);
+ DALI_INTERNAL MaskedImageView(Internal::MaskedImageView& implementation);
/**
* @brief Allows the creation of this Control from an Internal::CustomActor pointer.
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- MaskedImageView(Dali::Internal::CustomActor* internal);
+ explicit DALI_INTERNAL MaskedImageView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* to the stage as a separate overlay. In addition to the contents, an optional frame
* is displayed around the magnified contents.
*/
-class Magnifier : public Control
+class DALI_IMPORT_API Magnifier : public Control
{
public:
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL Magnifier(Dali::Internal::CustomActor* internal);
+ explicit DALI_INTERNAL Magnifier(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
*
*/
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
#include <dali-toolkit/public-api/controls/navigation-frame/page.h>
#include <dali-toolkit/public-api/controls/navigation-frame/navigation-bar-style.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* +----------------------------------------+
*/
-class NavigationControl : public Control
+class DALI_IMPORT_API NavigationControl : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- NavigationControl( Internal::NavigationControl& implementation );
+ DALI_INTERNAL NavigationControl( Internal::NavigationControl& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- NavigationControl( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL NavigationControl( Dali::Internal::CustomActor* internal );
}; // class NavigationControl
#include <dali-toolkit/public-api/controls/alignment/alignment.h>
#include <dali-toolkit/public-api/controls/popup/popup.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* It serves as the root of a navigation view.
* It also carries the title/subtitle/buttons/icons information which would be shown on the navigation bars when the item is on the top of the stack.
*/
-class Page : public Control
+class DALI_IMPORT_API Page : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] impl The Page implementation.
*/
- Page(Internal::Page& impl);
+ DALI_INTERNAL Page(Internal::Page& impl);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- Page( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Page( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/actors/actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* PageFactory is an abstract interface for providing image actors to PageTurnView
* Each image actor is identified by a unique ID, and has a linear order from 0 to GetNumberOfPages()-1
*/
-class PageFactory
+class DALI_IMPORT_API PageFactory
{
public:
// Property Names
//INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/page-turn-view/page-turn-view.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* PageTurnLandscapeView provides a page turn view in landscape mode
*/
-class PageTurnLandscapeView : public PageTurnView
+class DALI_IMPORT_API PageTurnLandscapeView : public PageTurnView
{
public:
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- PageTurnLandscapeView( Internal::PageTurnLandscapeView& implementation );
+ DALI_INTERNAL PageTurnLandscapeView( Internal::PageTurnLandscapeView& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- PageTurnLandscapeView( Dali::Internal::CustomActor* internal );
-
-
+ explicit DALI_INTERNAL PageTurnLandscapeView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
//INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/page-turn-view/page-turn-view.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* PageTurnLandscapeView provides a page turn view in portrait mode
*/
-class PageTurnPortraitView : public PageTurnView
+class DALI_IMPORT_API PageTurnPortraitView : public PageTurnView
{
public:
/**
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- PageTurnPortraitView( Internal::PageTurnPortraitView& implementation );
+ DALI_INTERNAL PageTurnPortraitView( Internal::PageTurnPortraitView& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- PageTurnPortraitView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL PageTurnPortraitView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Pan with no animation will occur when the user touches the page in an area that does not start the
* page turning.
*/
-class PageTurnView : public Control
+class DALI_IMPORT_API PageTurnView : public Control
{
public:
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL PageTurnView(Dali::Internal::CustomActor* internal);
+ explicit DALI_INTERNAL PageTurnView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* RotatingSelector is a simple control to switch between two states (selected/unselected). A signal is emitted when the selector switches between
* the two states. The control has two faces one behind the other, The control is rotated while switching between the two states
*/
-class RotatingSelector : public Control
+class DALI_IMPORT_API RotatingSelector : public Control
{
public:
//Signal Names
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- RotatingSelector( Internal::RotatingSelector& implementation );
+ DALI_INTERNAL RotatingSelector( Internal::RotatingSelector& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- RotatingSelector( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL RotatingSelector( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* shadowView.Deactivate();
* @endcode
*/
-class ShadowView : public Control
+class DALI_IMPORT_API ShadowView : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The UI Control implementation.
*/
- ShadowView( Internal::ShadowView& implementation );
+ DALI_INTERNAL ShadowView( Internal::ShadowView& implementation );
/**
* Allows the creation of this UI Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- ShadowView( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ShadowView( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
}
/**
- * Slider is a control to enable sliding an indicator between two values
+ * @brief Slider is a control to enable sliding an indicator between two values
*/
-class Slider : public Control
+class DALI_IMPORT_API Slider : public Control
{
public:
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- Slider(Internal::Slider& implementation);
+ DALI_INTERNAL Slider(Internal::Slider& implementation);
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- Slider( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL Slider( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* blurAnimation.AnimateTo( Property( blurView, blurView.GetBlurStrengthPropertyIndex() ), ... );\n
* blurAnimation.Play();\n
*/
-class SuperBlurView : public Control
+class DALI_IMPORT_API SuperBlurView : public Control
{
public:
*
* @param[in] internal A pointer to the internal CustomActor.
*/
- DALI_INTERNAL SuperBlurView(Dali::Internal::CustomActor* internal);
-
+ explicit DALI_INTERNAL SuperBlurView(Dali::Internal::CustomActor* internal);
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/alignment/alignment.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* is not forbidden, it adds controls on the left group with a size of 10% of the total tool bar size.
* Dali::Actor::Remove() method does nothing.
*/
-class ToolBar : public Control
+class DALI_IMPORT_API ToolBar : public Control
{
public:
static const Toolkit::Alignment::Padding DEFAULT_PADDING; ///< Default padding space between controls. By default all values are set to 0.
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- ToolBar( Internal::ToolBar& implementation );
+ DALI_INTERNAL ToolBar( Internal::ToolBar& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- ToolBar( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL ToolBar( Dali::Internal::CustomActor* internal );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* view.AddContentLayer( contentLayer );
* \endcode
*/
-class View : public Control
+class DALI_IMPORT_API View : public Control
{
public:
//Signal Names
* Creates a handle using the Toolkit::Internal implementation.
* @param[in] implementation The Control implementation.
*/
- View( Internal::View& implementation );
+ DALI_INTERNAL View( Internal::View& implementation );
/**
* Allows the creation of this Control from an Internal::CustomActor pointer.
* @param[in] internal A pointer to the internal CustomActor.
*/
- View( Dali::Internal::CustomActor* internal );
+ explicit DALI_INTERNAL View( Dali::Internal::CustomActor* internal );
};
-
} // namespace Toolkit
} // namespace Dali
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 15;
+const unsigned int TOOLKIT_MICRO_VERSION = 16;
const char * const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
*
*/
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+
namespace Dali
{
namespace Toolkit
{
-extern const unsigned int TOOLKIT_MAJOR_VERSION; ///< The major version number of the Toolkit.
-extern const unsigned int TOOLKIT_MINOR_VERSION; ///< The minor version number of the Toolkit.
-extern const unsigned int TOOLKIT_MICRO_VERSION; ///< The micro version number of the Toolkit.
-extern const char * const TOOLKIT_BUILD_DATE; ///< The date/time the Toolkit library was built.
+DALI_IMPORT_API extern const unsigned int TOOLKIT_MAJOR_VERSION; ///< The major version number of the Toolkit.
+DALI_IMPORT_API extern const unsigned int TOOLKIT_MINOR_VERSION; ///< The minor version number of the Toolkit.
+DALI_IMPORT_API extern const unsigned int TOOLKIT_MICRO_VERSION; ///< The micro version number of the Toolkit.
+DALI_IMPORT_API extern const char * const TOOLKIT_BUILD_DATE; ///< The date/time the Toolkit library was built.
} // namespace Toolkit
} // namespace Dali
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* BendyEffect is a custom shader effect to achieve bendy effects in Image actors
*/
-class BendyEffect : public ShaderEffect
+class DALI_IMPORT_API BendyEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- BendyEffect(ShaderEffect handle);
+ DALI_INTERNAL BendyEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* BlindEffect is a custom shader effect to achieve blind effects in Image actors
*/
-class BlindEffect : public ShaderEffect
+class DALI_IMPORT_API BlindEffect : public ShaderEffect
{
public:
const std::string& GetStepPropertyName() const;
private: // Not intended for application developers
- BlindEffect(ShaderEffect handle);
+ DALI_INTERNAL BlindEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* BubbleEffect is a custom shader to achieve similar effect of particle system by applying on a specially created MeshActor
* Each bubble is rendered on a patch with two triangles; and each mesh can contain multiple such patches.
*/
-class BubbleEffect : public ShaderEffect
+class DALI_IMPORT_API BubbleEffect : public ShaderEffect
{
public:
private:// Not intended for application developers
- BubbleEffect( ShaderEffect handle );
+ DALI_INTERNAL BubbleEffect( ShaderEffect handle );
private:
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* ColorAdjuster is a custom shader effect to adjust the image color in HSV space.
*/
-class ColorAdjuster : public ShaderEffect
+class DALI_IMPORT_API ColorAdjuster : public ShaderEffect
{
public:
private: // Not intended for application developers
-ColorAdjuster( ShaderEffect handle );
-
+ DALI_INTERNAL ColorAdjuster( ShaderEffect handle );
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Finally, the carousel's center position can be specified as a Screen coordinate (top-left being
* the origin).
*/
-class CarouselEffect : public ShaderEffect
+class DALI_IMPORT_API CarouselEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- CarouselEffect(ShaderEffect handle);
+ DALI_INTERNAL CarouselEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* animation.Play();\n
*
*/
-class DisplacementEffect : public ShaderEffect
+class DALI_IMPORT_API DisplacementEffect : public ShaderEffect
{
public:
private:
// Not intended for application developers
- DisplacementEffect(ShaderEffect handle);
+ DALI_INTERNAL DisplacementEffect(ShaderEffect handle);
};
}
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* DissolveLocalEffect is a custom shader effect to achieve Dissolve effects in multiple small areas of Image actors
*/
-class DissolveLocalEffect : public ShaderEffect
+class DALI_IMPORT_API DissolveLocalEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- DissolveLocalEffect( ShaderEffect handle );
+ DALI_INTERNAL DissolveLocalEffect( ShaderEffect handle );
private:
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* DistanceFieldEffect is a custom shader effect to achieve distance field on Image actors
*/
-class DistanceFieldEffect : public ShaderEffect
+class DALI_IMPORT_API DistanceFieldEffect : public ShaderEffect
{
public:
const std::string& GetGlowBoundaryPropertyName() const;
private:
- DistanceFieldEffect(ShaderEffect handle);
+ DALI_INTERNAL DistanceFieldEffect(ShaderEffect handle);
};
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* MirrorEffect is a custom shader effect to achieve square effects in Image actors
*/
-class MirrorEffect : public ShaderEffect
+class DALI_IMPORT_API MirrorEffect : public ShaderEffect
{
public:
const std::string& GetAlphaPropertyName() const;
private: // Not intended for application developers
- MirrorEffect(ShaderEffect handle);
+ DALI_INTERNAL MirrorEffect(ShaderEffect handle);
};
} // namespace Toolkit
#include <dali/public-api/actors/renderable-actor.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Actor.SetShaderEffect( MotionBlurEffect );
*
*/
-class MotionBlurEffect : public ShaderEffect
+class DALI_IMPORT_API MotionBlurEffect : public ShaderEffect
{
public:
private:
// Not intended for application developers
- MotionBlurEffect( ShaderEffect handle );
+ DALI_INTERNAL MotionBlurEffect( ShaderEffect handle );
};
}
#include <dali/public-api/actors/renderable-actor.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* Actor.SetShaderEffect( MotionStretchEffect );
*
*/
-class MotionStretchEffect : public ShaderEffect
+class DALI_IMPORT_API MotionStretchEffect : public ShaderEffect
{
public:
private:
// Not intended for application developers
- MotionStretchEffect( ShaderEffect handle );
+ DALI_INTERNAL MotionStretchEffect( ShaderEffect handle );
};
}
#include <dali/public-api/images/image.h>
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* ShearEffect is a custom shader effect to achieve shear effects in Image actors
*/
-class ShearEffect : public ShaderEffect
+class DALI_IMPORT_API ShearEffect : public ShaderEffect
{
public:
private: // Not intended for application developers
- ShearEffect(ShaderEffect handle);
+ DALI_INTERNAL ShearEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* animation.Play();\n
*
*/
-class SoftButtonEffect : public ShaderEffect
+class DALI_IMPORT_API SoftButtonEffect : public ShaderEffect
{
public:
private:
// Not intended for application developers
- SoftButtonEffect(ShaderEffect handle);
+ DALI_INTERNAL SoftButtonEffect(ShaderEffect handle);
};
}
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* SpotEffect2D is a custom shader effect to achieve spot effects on Image actors
*/
-class SpotEffect : public ShaderEffect
+class DALI_IMPORT_API SpotEffect : public ShaderEffect
{
public:
const std::string& GetRadiusPropertyName() const;
private:
- SpotEffect(ShaderEffect handle);
-
+ DALI_INTERNAL SpotEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
/**
* SquareDissolveEffect is a custom shader effect to achieve square effects in Image actors
*/
-class SquareDissolveEffect : public ShaderEffect
+class DALI_IMPORT_API SquareDissolveEffect : public ShaderEffect
{
public:
const std::string& GetTexSizePropertyName() const;
private: // Not intended for application developers
- SquareDissolveEffect(ShaderEffect handle);
+ DALI_INTERNAL SquareDissolveEffect(ShaderEffect handle);
};
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/shader-effects/shader-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* std::string propertyName = waterEffect.GetPropagationPropertyName( 1 );
* animation.AnimateTo( Property(waterEffect, propertyName), FINAL_RADIUS );
*/
-class WaterEffect : public ShaderEffect
+class DALI_IMPORT_API WaterEffect : public ShaderEffect
{
public:
public: // Not intended for developer use
- WaterEffect( ShaderEffect handle, Internal::WaterEffect* shaderExtension );
+ DALI_INTERNAL WaterEffect( ShaderEffect handle, Internal::WaterEffect* shaderExtension );
};
} // namespace Toolkit
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/transition-effects/cube-transition-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* SubClass of CubeTransitionEffect
* Rotate the neighboring cubes in perpendicular directions to transite from one image to another
*/
-class CubeTransitionCrossEffect : public CubeTransitionEffect
+class DALI_IMPORT_API CubeTransitionCrossEffect : public CubeTransitionEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect* impl );
+ explicit DALI_INTERNAL CubeTransitionCrossEffect( Internal::CubeTransitionCrossEffect* impl );
}; // class CubeTransitionCrossEffect
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/image-actor.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
*
* @endcode
*/
-class CubeTransitionEffect : public BaseHandle
+class DALI_IMPORT_API CubeTransitionEffect : public BaseHandle
{
public:
public: // Not intended for developer use
- CubeTransitionEffect( Internal::CubeTransitionEffect* impl );
+ explicit DALI_INTERNAL CubeTransitionEffect( Internal::CubeTransitionEffect* impl );
}; //class CubeTransitionEffect
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/transition-effects/cube-transition-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* SubClass of CubeTransitionEffect
* Rotate the neighboring cubes in opposite directions to transite from one image to another
*/
-class CubeTransitionFoldEffect : public CubeTransitionEffect
+class DALI_IMPORT_API CubeTransitionFoldEffect : public CubeTransitionEffect
{
public:
* This constructor is used by Dali New() methods.
* @param [in] impl A pointer to a newly allocated Dali resource
*/
- CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect* impl );
+ explicit DALI_INTERNAL CubeTransitionFoldEffect( Internal::CubeTransitionFoldEffect* impl );
}; // class CubeTransitionFoldEffect
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/transition-effects/cube-transition-effect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Toolkit
* SubClass of CubeTransitionEffect
* Rotate the cubes successively according to the finger movement to achieve wave-like transition effect
*/
-class CubeTransitionWaveEffect : public CubeTransitionEffect
+class DALI_IMPORT_API CubeTransitionWaveEffect : public CubeTransitionEffect
{
public:
* This constructor is used by Dali New() methods.
* @param[in] impl A pointer to a newly allocated Dali resource
*/
- CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect* impl );
+ explicit DALI_INTERNAL CubeTransitionWaveEffect( Internal::CubeTransitionWaveEffect* impl );
}; // class CubeTransitionWaveEffect
Name: dali-toolkit
Summary: The OpenGLES Canvas Core Library Toolkit
-Version: 1.0.15
+Version: 1.0.16
Release: 1
Group: System/Libraries
License: Apache-2.0
projects / platform / core / uifw / dali-toolkit.git / commitdiff