#define __DALI_TEST_APPLICATION_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali
{
-class DALI_IMPORT_API TestApplication : public ConnectionTracker
+class DALI_CORE_API TestApplication : public ConnectionTracker
{
public:
#define __DALI_TEST_GESTURE_MANAGER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Concrete implementation of the gesture manager class.
*/
-class DALI_IMPORT_API TestGestureManager : public Dali::Integration::GestureManager
+class DALI_CORE_API TestGestureManager : public Dali::Integration::GestureManager
{
public:
#define TEST_GL_ABSTRACTION_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
"aBoneIndices" // ATTRIB_BONE_INDICES
};
-class DALI_IMPORT_API TestGlAbstraction: public Dali::Integration::GlAbstraction
+class DALI_CORE_API TestGlAbstraction: public Dali::Integration::GlAbstraction
{
public:
TestGlAbstraction();
#define __TEST_GL_SYNC_ABSTRACTION_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali
{
-class DALI_IMPORT_API TestSyncObject : public Integration::GlSyncAbstraction::SyncObject
+class DALI_CORE_API TestSyncObject : public Integration::GlSyncAbstraction::SyncObject
{
public:
TestSyncObject(TraceCallStack& trace);
/**
* Class to emulate the GL sync functions with tracing
*/
-class DALI_IMPORT_API TestGlSyncAbstraction: public Integration::GlSyncAbstraction
+class DALI_CORE_API TestGlSyncAbstraction: public Integration::GlSyncAbstraction
{
public:
/**
#define __TEST_NATIVE_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
typedef IntrusivePtr<TestNativeImage> TestNativeImagePointer;
typedef IntrusivePtr<TestNativeImageNoExt> TestNativeImageNoExtPointer;
-class DALI_IMPORT_API TestNativeImageExtension: public Dali::NativeImageInterface::Extension
+class DALI_CORE_API TestNativeImageExtension: public Dali::NativeImageInterface::Extension
{
public:
inline const char* GetCustomFragmentPreFix(){return "#extension GL_OES_EGL_image_external:require\n";}
};
-class DALI_IMPORT_API TestNativeImage : public Dali::NativeImageInterface
+class DALI_CORE_API TestNativeImage : public Dali::NativeImageInterface
{
public:
static TestNativeImagePointer New(int width, int height);
};
-class DALI_IMPORT_API TestNativeImageNoExt : public Dali::NativeImageInterface
+class DALI_CORE_API TestNativeImageNoExt : public Dali::NativeImageInterface
{
public:
static TestNativeImageNoExtPointer New(int width, int height);
#define __DALI_TEST_PLATFORM_ABSTRACTION_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Concrete implementation of the platform abstraction class.
*/
-class DALI_IMPORT_API TestPlatformAbstraction : public Dali::Integration::PlatformAbstraction
+class DALI_CORE_API TestPlatformAbstraction : public Dali::Integration::PlatformAbstraction
{
public:
#define __TEST_RENDER_CONTROLLER_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali
{
-class DALI_IMPORT_API TestRenderController : public Dali::Integration::RenderController
+class DALI_CORE_API TestRenderController : public Dali::Integration::RenderController
{
public:
TestRenderController();
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
using namespace Dali;
-DALI_IMPORT_API const char* const GetName(Property::Type type);
-
int UtcDaliPropertyTypesGetNameP(void)
{
DALI_TEST_EQUALS( "NONE", Dali::PropertyTypes::GetName(Property::NONE ), TEST_LOCATION );
* @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_IMPORT_API VisibilityChangedSignalType& VisibilityChangedSignal( Actor actor );
+DALI_CORE_API VisibilityChangedSignalType& VisibilityChangedSignal( Actor actor );
typedef Signal< void (Actor) > ChildChangedSignalType; ///< Called when the actor has a child added or removed
* @return The signal to connect to
* @pre The Actor has been initialized
*/
-DALI_IMPORT_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_IMPORT_API ChildChangedSignalType& ChildRemovedSignal( Actor actor );
+DALI_CORE_API ChildChangedSignalType& ChildRemovedSignal( Actor actor );
} // namespace DevelActor
#define DALI_CUSTOM_ACTOR_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] actor The custom actor of which to get the type information
* @return the TypeInfo of this actor
*/
-DALI_IMPORT_API const Dali::TypeInfo GetTypeInfo( CustomActor actor );
+DALI_CORE_API const Dali::TypeInfo GetTypeInfo( CustomActor actor );
} // namespace DevelCustomActor
#define __DALI_ANIMATION_DATA_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* This then allows the same description data to be used to repeatedly create an animation multiple times.
*/
-class DALI_IMPORT_API AnimationData
+class DALI_CORE_API AnimationData
{
public:
#define DALI_ANIMATION_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @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_IMPORT_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_IMPORT_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_IMPORT_API Animation::AnimationSignalType& ProgressReachedSignal( Animation animation );
+DALI_CORE_API Animation::AnimationSignalType& ProgressReachedSignal( Animation animation );
} // namespace DevelAnimation
#define __DALI_PATH_CONSTRAINER_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* the tangent of the path given a forward vector in object's local space.
*
*/
-class DALI_IMPORT_API PathConstrainer : public Handle
+class DALI_CORE_API PathConstrainer : public Handle
{
public:
#define __DALI_HASH__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param toHash string to hash
* @return hash code
*/
-DALI_IMPORT_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_IMPORT_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_STAGE_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] stage The stage to emit a signal
* @return The return is true if KeyEvent is consumed, otherwise false.
*/
-DALI_IMPORT_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage );
+DALI_CORE_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage );
} // namespace DevelStage
#define __DALI_HIT_TEST_ALGORITHM_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] func The function to use in the hit-test algorithm.
* @return true if something was hit
*/
-DALI_IMPORT_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 );
/**
* @brief Hit test specific to a given RenderTask.
* @param[in] func The function to use in the hit-test algorithm.
* @return true if something was hit
*/
-DALI_IMPORT_API bool HitTest( RenderTask& renderTask, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
+DALI_CORE_API bool HitTest( RenderTask& renderTask, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
} // namespace HitTestAlgorithm
#define __DALI_DISTANCE_FIELD_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] maxSize The image is scaled from this size to distanceMapSize
* @param[in] highQuality Set true to generate high quality distance fields
*/
-DALI_IMPORT_API void GenerateDistanceFieldMap( const unsigned char* const imagePixels, const Vector2& imageSize,
+DALI_CORE_API void GenerateDistanceFieldMap( const unsigned char* const imagePixels, const Vector2& imageSize,
unsigned char* const distanceMap, const Vector2& distanceMapSize,
const unsigned int fieldBorder,
const Vector2& maxSize,
#define __DALI_NINE_PATCH_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* If you don't retain a handle to this object, it will be automatically destroyed.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API NinePatchImage : public ResourceImage
+class DALI_CORE_API NinePatchImage : public ResourceImage
{
public:
typedef Vector< Uint16Pair > StretchRanges;
#define DALI_TEXTURE_SET_IMAGE_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] index The position in the TextureSet that the image will be set
* @param[in] image The image to set
*/
-DALI_IMPORT_API void TextureSetImage( TextureSet textureSet, size_t index, Image image );
+DALI_CORE_API void TextureSetImage( TextureSet textureSet, size_t index, Image image );
} //namespace Dali
#define __DALI_CSHARP_TYPE_REGISTRY_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param [in] f registerType instance creation function
* @return true if the name could be registered.
*/
- DALI_IMPORT_API bool RegisterType( const std::string& name,
+ DALI_CORE_API bool RegisterType( const std::string& name,
const std::type_info& baseType,
CSharpTypeInfo::CreateFunction f );
* @param [in] getFunc The function to get the value of a property.
* @return true if the property could be registered.
*/
- DALI_IMPORT_API bool RegisterProperty( const std::string& objectName,
+ DALI_CORE_API bool RegisterProperty( const std::string& objectName,
const std::string& name,
Property::Index index,
Property::Type type,
*
* @note The key is not the same as the returned index, though it has the same type.
*/
-DALI_IMPORT_API Property::Index GetPropertyIndex( const Handle& handle, Property::Index key );
+DALI_CORE_API Property::Index GetPropertyIndex( const Handle& handle, Property::Index key );
/**
* @brief Query the index of a property using the given key from a Property::Map
*
* @note See also, GetPropertyIndex(Property::Index) and GetPropertyIndex(const std::string&)
*/
-DALI_IMPORT_API Property::Index GetPropertyIndex( const Handle& handle, Property::Key key );
+DALI_CORE_API Property::Index GetPropertyIndex( const Handle& handle, Property::Key key );
/**
* @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.
*/
-DALI_IMPORT_API Property::Index RegisterProperty( Handle handle, Property::Index key, const std::string& name, const Property::Value& propertyValue );
+DALI_CORE_API Property::Index RegisterProperty( Handle handle, Property::Index key, const std::string& name, const Property::Value& propertyValue );
/**
* @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_IMPORT_API void SetTypeInfo( Handle& handle, const TypeInfo& typeInfo );
+DALI_CORE_API void SetTypeInfo( Handle& handle, const TypeInfo& typeInfo );
/**
* @param[in] handle The handle to check
* @param[in] index The index of the property to test for
*/
-DALI_IMPORT_API bool DoesCustomPropertyExist( Handle& handle, Property::Index index );
+DALI_CORE_API bool DoesCustomPropertyExist( Handle& handle, Property::Index index );
/**
* @brief PropertySetSignal function prototype for signal handler. Called when a property is set on this object.
* @param[in] handle The handle of the object to listen to.
* @return The signal to attach a connection to.
*/
-DALI_IMPORT_API PropertySetSignalType& PropertySetSignal( Handle handle );
+DALI_CORE_API PropertySetSignalType& PropertySetSignal( Handle handle );
} // namespace DevelHandle
#define DALI_SCRIPTING_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @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_IMPORT_API unsigned int FindEnumIndex( const char* value, const StringEnum* table, unsigned int tableCount );
+DALI_CORE_API unsigned int FindEnumIndex( const char* value, const StringEnum* table, unsigned int 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_IMPORT_API bool EnumStringToInteger( const char* const value, const StringEnum* const table, unsigned int tableCount, int& integerEnum );
+DALI_CORE_API bool EnumStringToInteger( const char* const value, const StringEnum* const table, unsigned int tableCount, int& integerEnum );
/**
* @brief Chooses the appropriate enumeration for the provided string from the given table.
*
* @return A pointer to a newly created object.
*/
-DALI_IMPORT_API Image NewImage( const Property::Value& property );
+DALI_CORE_API Image NewImage( const Property::Value& property );
/**
* @brief Creates an actor with the date from the property value map.
*
* @return A handle to the newly created actor.
*/
-DALI_IMPORT_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_IMPORT_API void CreatePropertyMap( Actor actor, Property::Map& map );
+DALI_CORE_API void CreatePropertyMap( Actor actor, Property::Map& map );
/**
* @brief Creates a Property::Map from the image provided.
* @param[in] image The image from which a Property::Map should be created
* @param[out] map This map is cleared and a property map of the image is filled in
*/
-DALI_IMPORT_API void CreatePropertyMap( Image image, Property::Map& map );
+DALI_CORE_API void CreatePropertyMap( Image image, 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_IMPORT_API void NewAnimation( const Property::Map& map, Dali::AnimationData& outputAnimationData );
+DALI_CORE_API void NewAnimation( const Property::Map& map, Dali::AnimationData& outputAnimationData );
} // namespace Scripting
#define __DALI_SIGNAL_DELEGATE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* EG: The SignalDelegate can be created internally and exposed to the application-developer.
* They can then call the connect function to transparently bind to their callback.
*/
-class DALI_IMPORT_API SignalDelegate
+class DALI_CORE_API SignalDelegate
{
public:
#define __DALI_CONDITIONAL_WAIT_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Helper class to allow conditional waiting and notifications between multiple threads.
*/
-class DALI_IMPORT_API ConditionalWait
+class DALI_CORE_API ConditionalWait
{
public:
#define __DALI_MUTEX_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Class to synchronize access to critical resources from multiple threads
*/
-class DALI_IMPORT_API Mutex
+class DALI_CORE_API Mutex
{
public:
#define __DALI_THREAD_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/*
* @brief Abstract class for thread functionality. Can be used for worker threads.
*/
-class DALI_IMPORT_API Thread
+class DALI_CORE_API Thread
{
public:
#define __DALI_INTEGRATION_BITMAP_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[out] pixelDataType pixel data type (eg. GL_UNSIGNED_BYTE)
* @param[out] internalFormat pixel internal format (eg. GL_RGBA)
*/
-DALI_IMPORT_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
+DALI_CORE_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
class Bitmap;
typedef IntrusivePtr<Bitmap> BitmapPtr;
* Bitmap class.
* An abstract container for image data.
*/
-class DALI_IMPORT_API Bitmap : public Dali::RefObject
+class DALI_CORE_API Bitmap : public Dali::RefObject
{
protected:
* Interface to enable classes to be processed after the event loop. Classes are processed
* in the order they are registered.
*/
-class DALI_IMPORT_API Processor
+class DALI_CORE_API Processor
{
public:
/**
* This is the recommended option, so that input processing will not affect the smoothness of animations.
* Note that the rendering thread must be halted, before destroying the GL context.
*/
-class DALI_IMPORT_API Core
+class DALI_CORE_API Core
{
public:
#define __DALI_INTEGRATION_DEBUG_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param level debug level
* @param format string format
*/
-DALI_IMPORT_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.
* @param logFunction the log function to install
* @param logOpts the log options to save in thread
*/
-DALI_IMPORT_API void InstallLogFunction(const LogFunction& logFunction);
+DALI_CORE_API void InstallLogFunction(const LogFunction& logFunction);
/**
* A log function has to be uninstalled for every thread that wants to use logging.
* The log function can be different for each thread.
*/
-DALI_IMPORT_API void UninstallLogFunction();
+DALI_CORE_API void UninstallLogFunction();
/********************************************************************************
* Error/Warning macros. *
* It provides the ability to turn tracing on or off.
*
*/
-class DALI_IMPORT_API Filter
+class DALI_CORE_API Filter
{
public:
typedef std::list<Filter*> FilterList;
#ifdef DEBUG_ENABLED
-class DALI_IMPORT_API TraceObj
+class DALI_CORE_API TraceObj
{
public:
TraceObj(Filter* filter, const char* fmt, ...);
* @param[in] color - the color to translate
* @return string - the text representation of the color.
*/
-DALI_IMPORT_API std::string ColorToString(const Vector4& color);
+DALI_CORE_API std::string ColorToString(const Vector4& color);
/**
* Helper method to translate a vector4 to a string.
* @param[in] indent - the indent level to use.
* @return string - the text representation of the vector.
*/
-DALI_IMPORT_API std::string Vector4ToString(const Vector4& v, size_t precision=3, size_t indent=0);
+DALI_CORE_API std::string Vector4ToString(const Vector4& v, size_t precision=3, size_t indent=0);
/**
* Helper method to translate a vector4 to a string.
* @param[in] indent - the indent level to use.
* @return string - the text representation of the vector.
*/
-DALI_IMPORT_API std::string Vector3ToString(const Vector3& v, size_t precision=3, size_t indent=0);
+DALI_CORE_API std::string Vector3ToString(const Vector3& v, size_t precision=3, size_t indent=0);
/**
* Helper method to translate a quaternion to a string.
* @param[in] indent - the indent level to use.
* @return string - the text representation of the quaternion.
*/
-DALI_IMPORT_API std::string QuaternionToString(const Quaternion& q, size_t precision=3, size_t indent=0);
+DALI_CORE_API std::string QuaternionToString(const Quaternion& q, size_t precision=3, size_t indent=0);
/**
* Helper method to translate a 3x3 matrix to a string.
* @param[in] indent - the indent level to use.
* @return string - the text representation of the vector.
*/
-DALI_IMPORT_API std::string Matrix3ToString(const Matrix3& m, size_t precision=3, size_t indent=0);
+DALI_CORE_API std::string Matrix3ToString(const Matrix3& m, size_t precision=3, size_t indent=0);
/**
* Helper method to translate a 4x4 matrix to a string.
* @param[in] indent - the indent level to use.
* @return string - the text representation of the vector.
*/
-DALI_IMPORT_API std::string MatrixToString(const Matrix& m, size_t precision=3, size_t indent=0);
+DALI_CORE_API std::string MatrixToString(const Matrix& m, size_t precision=3, size_t indent=0);
#ifdef DEBUG_ENABLED
#define __DALI_INTEGRATION_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* Base structure for events passed to Dali::Integration::Core::QueueEvent()
* An instance of this class cannot be created.
*/
-struct Event
+struct DALI_CORE_API Event
{
// Destruction
#define __DALI_INTEGRATION_GESTURE_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/events/gesture.h>
#include <dali/integration-api/events/event.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* This is the abstract base structure for any gestures that the adaptor detects and wishes to send
* to the Core.
*/
-struct GestureEvent : public Event
+struct DALI_CORE_API GestureEvent : public Event
{
// Destruction
#define __DALI_INTEGRATION_GESTURE_REQUESTS_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/public-api/events/gesture.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
/**
* This structure specifies the gesture type required (or no longer required) by Core.
*/
-struct GestureRequest
+struct DALI_CORE_API GestureRequest
{
// Creation & Destruction
/**
* This is used by Core when a pan gesture is required.
*/
-struct PanGestureRequest : public GestureRequest
+struct DALI_CORE_API PanGestureRequest : public GestureRequest
{
// Creation & Destruction
/**
* This is used by Core when a pinch gesture is required.
*/
-struct PinchGestureRequest : public GestureRequest
+struct DALI_CORE_API PinchGestureRequest : public GestureRequest
{
// Creation & Destruction
/**
* This is used by Core when a tap gesture is required.
*/
-struct TapGestureRequest : public GestureRequest
+struct DALI_CORE_API TapGestureRequest : public GestureRequest
{
// Creation & Destruction
/**
* This is used by Core when a long press gesture is required.
*/
-struct LongPressGestureRequest : public GestureRequest
+struct DALI_CORE_API LongPressGestureRequest : public GestureRequest
{
// Creation & Destruction
#define __DALI_INTEGRATION_HOVER_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/events/hover-event.h>
#include <dali/integration-api/events/multi-point-event-integ.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* This class can contain one or many touch points. It also contains the time at which the
* event occurred.
*/
-struct HoverEvent : public MultiPointEvent
+struct DALI_CORE_API HoverEvent : public MultiPointEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_KEY_EVENT_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/event.h>
#include <dali/public-api/events/key-event.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* the Dali core.
*
*/
-struct KeyEvent : public Event
+struct DALI_CORE_API KeyEvent : public Event
{
// Enumerations
// Specifies the state of the key event.
#define __DALI_INTEGRATION_LONG_PRESS_GESTURE_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/gesture-event.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* - Finished: When the user finally lifts all touches.
* - Cancelled: If, after a down event, no long press is detected, or a system interruption.
*/
-struct LongPressGestureEvent : public GestureEvent
+struct DALI_CORE_API LongPressGestureEvent : public GestureEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_MULTI_POINT_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/event.h>
#include <dali/integration-api/events/point.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* This class can contain one or multiple touch points. It also contains the time at which the
* event occurred.
*/
-struct MultiPointEvent : public Event
+struct DALI_CORE_API MultiPointEvent : public Event
{
// Construction & Destruction
#define __DALI_INTEGRATION_PAN_GESTURE_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/gesture-event.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* A Started state will be ignored if a Possible state does not precede it.
* Likewise, a Continuing or Finished state will be ignored if a Started state does not precede it.
*/
-struct PanGestureEvent: public GestureEvent
+struct DALI_CORE_API PanGestureEvent: public GestureEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_PINCH_GESTURE_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/gesture-event.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* - Finished: If after a pinch, the user lifts their finger(s).
* - Cancelled: If there is a system interruption.
*/
-struct PinchGestureEvent : public GestureEvent
+struct DALI_CORE_API PinchGestureEvent : public GestureEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_POINT_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* @brief A Point represents a point on the screen that is currently being touched or where touch has stopped.
*/
-struct DALI_IMPORT_API Point
+struct DALI_CORE_API Point
{
/**
* @brief Default Constructor
#define __DALI_INTEGRATION_TAP_GESTURE_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/gesture-event.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
*
* A Started state will be ignored if a Possible state does not precede it.
*/
-struct TapGestureEvent : public GestureEvent
+struct DALI_CORE_API TapGestureEvent : public GestureEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_TOUCH_EVENT_COMBINER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* - Motion event throttling is carried out to satisfy the minimum distance and time delta required.
* - If an interrupted event is received, then any stored Point history is cleared.
*/
-class DALI_IMPORT_API TouchEventCombiner
+class DALI_CORE_API TouchEventCombiner
{
public:
#define __DALI_INTEGRATION_TOUCH_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/events/touch-event.h>
#include <dali/integration-api/events/multi-point-event-integ.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* This class can contain one or many touch points. It also contains the time at which the
* event occurred.
*/
-struct TouchEvent : public MultiPointEvent
+struct DALI_CORE_API TouchEvent : public MultiPointEvent
{
// Construction & Destruction
#define __DALI_INTEGRATION_WHEEL_EVENT_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/events/event.h>
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Integration
* the Dali core.
*
*/
-struct WheelEvent : public Event
+struct DALI_CORE_API WheelEvent : public Event
{
// Enumerations
#define __DALI_INTEGRATION_GESTURE_MANAGER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* by the adaptor. A concrete implementation must be created for each adaptor, and provided when creating
* the Dali::Integration::Core object.
*/
-class DALI_IMPORT_API GestureManager
+class DALI_CORE_API GestureManager
{
public:
#define __DALI_INTEGRATION_INPUT_OPTIONS_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @pre Should be called after Core creation.
* @param mode The pan gesture prediction mode.
*/
-DALI_IMPORT_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_IMPORT_API void SetPanGesturePredictionAmount(unsigned int amount);
+DALI_CORE_API void SetPanGesturePredictionAmount(unsigned int amount);
/**
* @brief Sets the upper bound of the prediction amount for clamping
*
* @param[in] amount The prediction amount in milliseconds
*/
-DALI_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_API void SetPanGestureMultitapSmoothingRange( int value );
+DALI_CORE_API void SetPanGestureMultitapSmoothingRange( int value );
} // namespace Integration
#define __DALI_INTEGRATION_LOCKLESS_BUFFER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* In case the other thread is writing at that moment, buffers are not swapped and previously available data is read.
* Similarly if Write() is called before a Read() has finished the previous write buffer is overwritten.
*/
-class DALI_IMPORT_API LocklessBuffer
+class DALI_CORE_API LocklessBuffer
{
public:
#define __DALI_INTEGRATION_PROFILING_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @pre Should be called after Core creation.
* @param type The type of profiling information to output.
*/
-DALI_IMPORT_API void EnableProfiling( ProfilingType type );
+DALI_CORE_API void EnableProfiling( ProfilingType type );
namespace Profiling
{
-DALI_IMPORT_API extern const int ANIMATION_MEMORY_SIZE; ///< Total size of animation and associated internal objects
-DALI_IMPORT_API extern const int CONSTRAINT_MEMORY_SIZE; ///< Total size of constraint and associated internal objects
-DALI_IMPORT_API extern const int ACTOR_MEMORY_SIZE; ///< Total size of actor and associated internal objects
-DALI_IMPORT_API extern const int CAMERA_ACTOR_MEMORY_SIZE; ///< Total size of camera actor and associated internal objects
-DALI_IMPORT_API extern const int IMAGE_ACTOR_MEMORY_SIZE; ///< Total size of image actor and associated internal objects
-DALI_IMPORT_API extern const int LAYER_MEMORY_SIZE; ///< Total size of layer and associated internal objects
-DALI_IMPORT_API extern const int IMAGE_MEMORY_SIZE; ///< Total size of image and associated internal objects
+DALI_CORE_API extern const int ANIMATION_MEMORY_SIZE; ///< Total size of animation and associated internal objects
+DALI_CORE_API extern const int CONSTRAINT_MEMORY_SIZE; ///< Total size of constraint and associated internal objects
+DALI_CORE_API extern const int ACTOR_MEMORY_SIZE; ///< Total size of actor and associated internal objects
+DALI_CORE_API extern const int CAMERA_ACTOR_MEMORY_SIZE; ///< Total size of camera actor and associated internal objects
+DALI_CORE_API extern const int IMAGE_ACTOR_MEMORY_SIZE; ///< Total size of image actor and associated internal objects
+DALI_CORE_API extern const int LAYER_MEMORY_SIZE; ///< Total size of layer and associated internal objects
+DALI_CORE_API extern const int IMAGE_MEMORY_SIZE; ///< Total size of image and associated internal objects
-DALI_IMPORT_API extern const int RENDERER_MEMORY_SIZE; ///< Total size of renderer and associated internal objects
-DALI_IMPORT_API extern const int GEOMETRY_MEMORY_SIZE; ///< Total size of geometry and associated internal objects
-DALI_IMPORT_API extern const int PROPERTY_BUFFER_MEMORY_SIZE; ///< Total size of property-0buffer and associated internal objects
-DALI_IMPORT_API extern const int TEXTURE_SET_MEMORY_SIZE; ///< Total size of TextureSet and associated internal objects
-DALI_IMPORT_API extern const int SAMPLER_MEMORY_SIZE; ///< Total size of Sampler and associated internal objects
-DALI_IMPORT_API extern const int SHADER_MEMORY_SIZE; ///< Total size of shader and associated internal objects
+DALI_CORE_API extern const int RENDERER_MEMORY_SIZE; ///< Total size of renderer and associated internal objects
+DALI_CORE_API extern const int GEOMETRY_MEMORY_SIZE; ///< Total size of geometry and associated internal objects
+DALI_CORE_API extern const int PROPERTY_BUFFER_MEMORY_SIZE; ///< Total size of property-0buffer and associated internal objects
+DALI_CORE_API extern const int TEXTURE_SET_MEMORY_SIZE; ///< Total size of TextureSet and associated internal objects
+DALI_CORE_API extern const int SAMPLER_MEMORY_SIZE; ///< Total size of Sampler and associated internal objects
+DALI_CORE_API extern const int SHADER_MEMORY_SIZE; ///< Total size of shader and associated internal objects
} // namespace Profiling
} // namespace Integration
#define __DALI_INTEGRATION_SYSTEM_OVERLAY_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* Use this interface to draw content for system-level indicators, dialogs etc.
* The SystemOverlay is accessible using Dali::Integration::Core::GetSystemOverlay().
*/
-class DALI_IMPORT_API SystemOverlay
+class DALI_CORE_API SystemOverlay
{
public:
* @param start a bool to indicate start (true) or end (false) of the tracing / logging
* @param tag a unique event tag name
*/
-DALI_IMPORT_API void LogContext( bool start, const char* tag );
+DALI_CORE_API void LogContext( bool start, const char* tag );
/**
* typedef for the LogContextFunction function.
* The LogContextFunction function can be different for each thread.
* @param LogContextFunction the Log Context function to install
*/
-DALI_IMPORT_API void InstallLogContextFunction( const LogContextFunction& logContextFunction );
+DALI_CORE_API void InstallLogContextFunction( const LogContextFunction& logContextFunction );
/********************************************************************************
* Filter *
* It provides the ability to turn tracing on or off.
*
*/
-class DALI_IMPORT_API Filter
+class DALI_CORE_API Filter
{
public:
* and uses filter object which in tun routes the tracing via the platform abstraction's LogMessage.
*
*/
-class DALI_IMPORT_API Tracer final
+class DALI_CORE_API Tracer final
{
public:
Tracer( Filter* filter, const char* tag );
#define DALI_ACTOR_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Actor : public Handle
+class DALI_CORE_API Actor : public Handle
{
public:
#define __DALI_CAMERA_ACTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API CameraActor : public Actor
+class DALI_CORE_API CameraActor : public Actor
{
public:
#define __DALI_CUSTOM_ACTOR_IMPL_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* And CustomActorImpl is typically owned by a single CustomActor instance; see also CustomActor::CustomActor( CustomActorImpl &implementation ).
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API CustomActorImpl : public Dali::RefObject
+class DALI_CORE_API CustomActorImpl : public Dali::RefObject
{
public:
#define __DALI_CUSTOM_ACTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* The implementation of the control must be supplied; see CustomActorImpl for more details.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API CustomActor : public Actor
+class DALI_CORE_API CustomActor : public Actor
{
public:
#define DALI_LAYER_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | lowerToBottom | @ref LowerToBottom() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Layer : public Actor
+class DALI_CORE_API Layer : public Actor
{
public:
#define __DALI_ALPHA_FUNCTION_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* the animation before computing the final animation value.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API AlphaFunction
+class DALI_CORE_API AlphaFunction
{
public:
#define DALI_ANIMATION_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | pause | Pause() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Animation : public BaseHandle
+class DALI_CORE_API Animation : public BaseHandle
{
public:
#define __DALI_CONSTRAINT_SOURCE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Identifies a property from an object.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API LocalSource
+struct DALI_CORE_API LocalSource
{
/**
* @brief Creates a local constraint source.
* @brief Identifies a property from the parent of an object.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API ParentSource
+struct DALI_CORE_API ParentSource
{
/**
* @brief Creates a parent constraint source.
* @brief Identifies a property from any object.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API Source
+struct DALI_CORE_API Source
{
/**
* @brief Creates a constraint source.
* @brief The source of an input property for a constraint.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API ConstraintSource
+struct DALI_CORE_API ConstraintSource
{
/**
* @brief Creates a constraint source.
#define __DALI_CONSTRAINT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @endcode
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Constraint : public BaseHandle
+class DALI_CORE_API Constraint : public BaseHandle
{
public:
#define __DALI_KEY_FRAMES_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* different Property::Value type will result in a run time assert.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API KeyFrames : public BaseHandle
+class DALI_CORE_API KeyFrames : public BaseHandle
{
public:
/**
#define __DALI_LINEAR_CONSTRAINER_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* target and the source as the actor's position.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API LinearConstrainer : public Handle
+class DALI_CORE_API LinearConstrainer : public Handle
{
public:
#define __DALI_PATH_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Path : public Handle
+class DALI_CORE_API Path : public Handle
{
public:
#define __DALI_TIME_PERIOD_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A value-type representing a period of time within an animation.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API TimePeriod
+struct DALI_CORE_API TimePeriod
{
/**
* @brief Creates a time period.
#define __DALI_CONSTANTS_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
static const float RIGHT = 1.0f;
static const float MIDDLE = 0.5f;
-DALI_IMPORT_API extern const Vector3 TOP_LEFT; ///< 0.0f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 TOP_CENTER; ///< 0.5f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 TOP_RIGHT; ///< 1.0f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER_LEFT; ///< 0.0f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER; ///< 0.5f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER_RIGHT; ///< 1.0f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_LEFT; ///< 0.0f, 1.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_CENTER; ///< 0.5f, 1.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_RIGHT; ///< 1.0f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_LEFT; ///< 0.0f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_CENTER; ///< 0.5f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_RIGHT; ///< 1.0f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER_LEFT; ///< 0.0f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER; ///< 0.5f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER_RIGHT; ///< 1.0f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_LEFT; ///< 0.0f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_CENTER; ///< 0.5f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_RIGHT; ///< 1.0f, 1.0f, 0.5f
}
static const float MIDDLE = 0.5f;
extern const Vector3 DEFAULT; ///< CENTER
-DALI_IMPORT_API extern const Vector3 TOP_LEFT; ///< 0.0f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 TOP_CENTER; ///< 0.5f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 TOP_RIGHT; ///< 1.0f, 0.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER_LEFT; ///< 0.0f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER; ///< 0.5f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 CENTER_RIGHT; ///< 1.0f, 0.5f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_LEFT; ///< 0.0f, 1.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_CENTER; ///< 0.5f, 1.0f, 0.5f
-DALI_IMPORT_API extern const Vector3 BOTTOM_RIGHT; ///< 1.0f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_LEFT; ///< 0.0f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_CENTER; ///< 0.5f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 TOP_RIGHT; ///< 1.0f, 0.0f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER_LEFT; ///< 0.0f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER; ///< 0.5f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 CENTER_RIGHT; ///< 1.0f, 0.5f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_LEFT; ///< 0.0f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_CENTER; ///< 0.5f, 1.0f, 0.5f
+DALI_CORE_API extern const Vector3 BOTTOM_RIGHT; ///< 1.0f, 1.0f, 0.5f
}
*/
namespace Color
{
-DALI_IMPORT_API extern const Vector4 BLACK; ///< Pure black (0.0f, 0.0f, 0.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 WHITE; ///< Pure white (1.0f, 1.0f, 1.0f, 1.0f);
+DALI_CORE_API extern const Vector4 BLACK; ///< Pure black (0.0f, 0.0f, 0.0f, 1.0f);
+DALI_CORE_API extern const Vector4 WHITE; ///< Pure white (1.0f, 1.0f, 1.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 RED; ///< Pure red (1.0f, 0.0f, 0.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 GREEN; ///< Pure green (0.0f, 1.0f, 0.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 BLUE; ///< Pure blue (0.0f, 0.0f, 1.0f, 1.0f);
+DALI_CORE_API extern const Vector4 RED; ///< Pure red (1.0f, 0.0f, 0.0f, 1.0f);
+DALI_CORE_API extern const Vector4 GREEN; ///< Pure green (0.0f, 1.0f, 0.0f, 1.0f);
+DALI_CORE_API extern const Vector4 BLUE; ///< Pure blue (0.0f, 0.0f, 1.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 YELLOW; ///< Pure yellow (1.0f, 1.0f, 0.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 MAGENTA; ///< Pure magenta (1.0f, 0.0f, 1.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 CYAN; ///< Pure cyan (0.0f, 1.0f, 1.0f, 1.0f);
+DALI_CORE_API extern const Vector4 YELLOW; ///< Pure yellow (1.0f, 1.0f, 0.0f, 1.0f);
+DALI_CORE_API extern const Vector4 MAGENTA; ///< Pure magenta (1.0f, 0.0f, 1.0f, 1.0f);
+DALI_CORE_API extern const Vector4 CYAN; ///< Pure cyan (0.0f, 1.0f, 1.0f, 1.0f);
-DALI_IMPORT_API extern const Vector4 TRANSPARENT; ///< Black transparent (0.0f, 0.0f, 0.0f, 0.0f);
+DALI_CORE_API extern const Vector4 TRANSPARENT; ///< Black transparent (0.0f, 0.0f, 0.0f, 0.0f);
} // namespace Color
*/
namespace Math
{
-DALI_IMPORT_API extern const float MACHINE_EPSILON_0; ///< Epsilon for values near zero
-DALI_IMPORT_API extern const float MACHINE_EPSILON_1; ///< Epsilon for values near 1
-DALI_IMPORT_API extern const float MACHINE_EPSILON_10; ///< Epsilon for values near 10
-DALI_IMPORT_API extern const float MACHINE_EPSILON_100; ///< Epsilon for values near 100
-DALI_IMPORT_API extern const float MACHINE_EPSILON_1000; ///< Epsilon for values near 1000
-DALI_IMPORT_API extern const float MACHINE_EPSILON_10000; ///< Epsilon for values near 10000
+DALI_CORE_API extern const float MACHINE_EPSILON_0; ///< Epsilon for values near zero
+DALI_CORE_API extern const float MACHINE_EPSILON_1; ///< Epsilon for values near 1
+DALI_CORE_API extern const float MACHINE_EPSILON_10; ///< Epsilon for values near 10
+DALI_CORE_API extern const float MACHINE_EPSILON_100; ///< Epsilon for values near 100
+DALI_CORE_API extern const float MACHINE_EPSILON_1000; ///< Epsilon for values near 1000
+DALI_CORE_API extern const float MACHINE_EPSILON_10000; ///< Epsilon for values near 10000
// float is preferred to double for performance on ARM targets
static const float PI = static_cast<float>(M_PI); ///< Constant representing PI
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return result;
}
-DALI_EXPORT_API DaliException::DaliException( const char* location, const char* 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
#else // BACKTRACE_ENABLED
-DALI_EXPORT_API DaliException::DaliException( const char* location, const char* condition )
+DALI_CORE_API DaliException::DaliException( const char* location, const char* condition )
: location( location ), condition( condition )
{
#if defined(DEBUG_ENABLED)
#endif // BACKTRACE_ENABLED
-DALI_EXPORT_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 );
#define __DALI_COMMON_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
# ifndef HIDE_DALI_INTERNALS
# define DALI_EXPORT_API
# define DALI_IMPORT_API
+# define DALI_CORE_API
# define DALI_INTERNAL
# else
# define DALI_EXPORT_API __attribute__ ((visibility ("default")))
# define DALI_IMPORT_API __attribute__ ((visibility ("default")))
+# define DALI_CORE_API __attribute__ ((visibility ("default")))
# define DALI_INTERNAL __attribute__ ((visibility ("hidden")))
# endif
#else
# define DALI_EXPORT_API
/** Visibility attribute to show declarations */
# define DALI_IMPORT_API
+/** Visibility attribute to show declarations */
+# define DALI_CORE_API
/** Visibility attribute to hide declarations */
# define DALI_INTERNAL
#endif
* @param[in] location Where the assertion occurred
* @param[in] condition The assertion condition
*/
-DALI_IMPORT_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.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API DaliException
+class DALI_CORE_API DaliException
{
public:
/**
#define __DALI_VECTOR_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* beginning of the first real item so that iterating the items is quick.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API VectorBase
+class DALI_CORE_API VectorBase
{
public: // Typedefs
#define DALI_EXTENTS_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Structure describing the a collection of uint16_t.
* @SINCE_1_2.62
*/
-struct DALI_EXPORT_API Extents
+struct DALI_CORE_API Extents
{
/**
* @brief Default constructor which provides an initialized Dali::Extents( 0u, 0u, 0u, 0u ).
* @param[in] extents The Extents to output
* @return The output stream operator
*/
-DALI_EXPORT_API std::ostream& operator<<( std::ostream& stream, const Extents& extents );
+DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Extents& extents );
/**
* @}
#define __DALI_STAGE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | sceneCreated | @ref SceneCreatedSignal() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Stage : public BaseHandle
+class DALI_CORE_API Stage : public BaseHandle
{
public:
#define __DALI_CORE_VERSION_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali
{
-DALI_IMPORT_API extern const unsigned int CORE_MAJOR_VERSION; ///< The major version number of the Core library.
-DALI_IMPORT_API extern const unsigned int CORE_MINOR_VERSION; ///< The minor version number of the Core library.
-DALI_IMPORT_API extern const unsigned int CORE_MICRO_VERSION; ///< The micro version number of the Core library.
-DALI_IMPORT_API extern const char * const CORE_BUILD_DATE; ///< The date/time the Core library was built.
+DALI_CORE_API extern const unsigned int CORE_MAJOR_VERSION; ///< The major version number of the Core library.
+DALI_CORE_API extern const unsigned int CORE_MINOR_VERSION; ///< The minor version number of the Core library.
+DALI_CORE_API extern const unsigned int 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__
#define __DALI_GESTURE_DETECTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
* @see Gesture
*/
-class DALI_IMPORT_API GestureDetector : public Handle
+class DALI_CORE_API GestureDetector : public Handle
{
public: // Creation & Destruction
#define __DALI_GESTURE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @see GestureDetector
*
*/
-struct DALI_IMPORT_API Gesture
+struct DALI_CORE_API Gesture
{
/**
* @brief Copy constructor.
#define __DALI_HOVER_EVENT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* hovered or the points where a hover has stopped.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API HoverEvent
+struct DALI_CORE_API HoverEvent
{
// Construction & Destruction
#define __DALI_KEY_EVENT_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* module.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API KeyEvent
+struct DALI_CORE_API KeyEvent
{
// Enumerations
#define __DALI_LONG_PRESS_GESTURE_DETECTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* |-------------------|-----------------------|
* | longPressDetected | @ref DetectedSignal() |
*/
-class DALI_IMPORT_API LongPressGestureDetector : public GestureDetector
+class DALI_CORE_API LongPressGestureDetector : public GestureDetector
{
public: // Typedefs
#define __DALI_LONG_PRESS_GESTURE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
* @see LongPressGestureDetector
*/
-struct DALI_IMPORT_API LongPressGesture : public Gesture
+struct DALI_CORE_API LongPressGesture : public Gesture
{
// Construction & Destruction
#define __DALI_PAN_GESTURE_DETECTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* |--------------|-----------------------|
* | panDetected | @ref DetectedSignal() |
*/
-class DALI_IMPORT_API PanGestureDetector : public GestureDetector
+class DALI_CORE_API PanGestureDetector : public GestureDetector
{
public:
#define __DALI_PAN_GESTURE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* A pan gesture will continue to be sent to the actor under than initial pan until it ends.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API PanGesture: public Gesture
+struct DALI_CORE_API PanGesture: public Gesture
{
// Construction & Destruction
#define __DALI_PINCH_GESTURE_DETECTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* |----------------|-----------------------|
* | pinchDetected | @ref DetectedSignal() |
*/
-class DALI_IMPORT_API PinchGestureDetector : public GestureDetector
+class DALI_CORE_API PinchGestureDetector : public GestureDetector
{
public: // Typedefs
#define __DALI_PINCH_GESTURE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* until the pinch ends.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API PinchGesture: public Gesture
+struct DALI_CORE_API PinchGesture: public Gesture
{
// Construction & Destruction
#define __DALI_TAP_GESTURE_DETECTOR_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @see TapGesture
*
*/
-class DALI_IMPORT_API TapGestureDetector : public GestureDetector
+class DALI_CORE_API TapGestureDetector : public GestureDetector
{
public: // Typedefs
#define __DALI_TAP_GESTURE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
* @see TapGestureDetector
*/
-struct DALI_IMPORT_API TapGesture : public Gesture
+struct DALI_CORE_API TapGesture : public Gesture
{
// Construction & Destruction
#define __DALI_TOUCH_DATA_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* Should not use this in a TouchData container as it is just a handle and the internal object can change.
*/
-class DALI_IMPORT_API TouchData : public BaseHandle
+class DALI_CORE_API TouchData : public BaseHandle
{
public:
#define __DALI_TOUCH_EVENT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* touched or the points where a touch has stopped.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API TouchEvent
+struct DALI_CORE_API TouchEvent
{
// Construction & Destruction
#define __DALI_TOUCH_POINT_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* or where touch has stopped.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API TouchPoint
+struct DALI_CORE_API TouchPoint
{
// Enumerations
#define __DALI_WHEEL_EVENT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* The mouse wheel event can be sent to the specific actor but the custom wheel event will be sent to the stage.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API WheelEvent
+struct DALI_CORE_API WheelEvent
{
// Enumerations
#define __DALI_BUFFER_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API BufferImage : public Image
+class DALI_CORE_API BufferImage : public Image
{
public:
#define __DALI_ENCODED_BUFFER_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* uploaded to the OpenGL ES implementation.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API EncodedBufferImage : public Image
+class DALI_CORE_API EncodedBufferImage : public Image
{
public:
#define __DALI_FRAME_BUFFER_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* The FrameBufferImage can then be used for rendering to the screen.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API FrameBufferImage : public Image
+class DALI_CORE_API FrameBufferImage : public Image
{
public:
#define __DALI_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | uploaded | @ref UploadedSignal() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Image : public BaseHandle
+class DALI_CORE_API Image : public BaseHandle
{
public:
#define __DALI_NATIVE_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* Its data is provided by native resources, such as shared bitmap memory or pixmap.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API NativeImage : public Image
+class DALI_CORE_API NativeImage : public Image
{
public:
#define DALI_PIXEL_DATA_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API PixelData : public BaseHandle
+class DALI_CORE_API PixelData : public BaseHandle
{
public:
#define __DALI_PIXEL_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] pixelformat Pixel format
* @return @c true if format has alpha, @c false otherwise
*/
-DALI_IMPORT_API bool HasAlpha(Format pixelformat);
+DALI_CORE_API bool HasAlpha(Format pixelformat);
/**
* @brief Returns The number of bytes per pixel for the specified pixel format.
* @param[in] pixelFormat The pixel format
* @return The number of bytes per pixel
*/
-DALI_IMPORT_API unsigned int GetBytesPerPixel(Format pixelFormat);
+DALI_CORE_API unsigned int GetBytesPerPixel(Format pixelFormat);
/**
* @brief Returns the offset of the byte containing the alpha value from the start of the pixel data
* @param[out] bitMask The bitmask of the byte to get the alpha value
*
*/
-DALI_IMPORT_API void GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask);
+DALI_CORE_API void GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask);
} //namespace Pixel
#define __DALI_RESOURCE_IMAGE_H__
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | imageLoadingFinished | @ref LoadingFinishedSignal() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API ResourceImage : public Image
+class DALI_CORE_API ResourceImage : public Image
{
public:
#define __DALI_DEGREE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
* @param[in] value The initial value in Radians
*/
- DALI_EXPORT_API Degree( Radian value );
+ DALI_CORE_API Degree( Radian value );
public:
// compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
// useful constant angles
-DALI_EXPORT_API extern const Radian ANGLE_360; ///< 360 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_315; ///< 315 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_270; ///< 270 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_225; ///< 225 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_180; ///< 180 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_135; ///< 135 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_120; ///< 120 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_90; ///< 90 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_60; ///< 60 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_45; ///< 45 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_30; ///< 30 degree turn in radians
-DALI_EXPORT_API extern const Radian ANGLE_0; ///< 0 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_360; ///< 360 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_315; ///< 315 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_270; ///< 270 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_225; ///< 225 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_180; ///< 180 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_135; ///< 135 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_120; ///< 120 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_90; ///< 90 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_60; ///< 60 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_45; ///< 45 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_30; ///< 30 degree turn in radians
+DALI_CORE_API extern const Radian ANGLE_0; ///< 0 degree turn in radians
/**
* @brief Compares equality between two degrees.
#define __DALI_MATRIX_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* Each axis is contiguous in memory, so the x axis corresponds to elements 0, 1, 2 and 3, the y axis corresponds to elements 4, 5, 6, 7, etc.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Matrix
+class DALI_CORE_API Matrix
{
public:
* @param[in] matrix The matrix to print
* @return The output stream operator
*/
-DALI_IMPORT_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 }; };
#define __DALI_MATRIX3_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Matrix3
+class DALI_CORE_API Matrix3
{
public:
* @param[in] matrix The matrix to print
* @return The output stream operator
*/
-DALI_IMPORT_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 }; };
#define __DALI_QUATERNION_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief The Quaternion class encapsulates the mathematics of the quaternion.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Quaternion
+class DALI_CORE_API Quaternion
{
public:
* @param[in] quaternion The quaternion to print
* @return The output stream operator
*/
-DALI_IMPORT_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 }; };
#define __DALI_VECTOR_2_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A two dimensional vector.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API Vector2
+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.
* @param[in] vector The vector to print
* @return The output stream operator
*/
-DALI_IMPORT_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] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_IMPORT_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 }; };
#define __DALI_VECTOR_3_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A three dimensional vector.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API Vector3
+struct DALI_CORE_API Vector3
{
// Construction
* @param[in] vector The vector to print
* @return The output stream operator
*/
-DALI_IMPORT_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] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_IMPORT_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 }; };
#define __DALI_VECTOR_4_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* Components can be used as position or offset (x,y,z,w); color (r,g,b,a) or texture coords(s,t,p,q).
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API Vector4
+struct DALI_CORE_API Vector4
{
// NOTE
// xrs, ygt, zbp and waq must be consecutive in memory.
* @param[in] vector The vector to print
* @return The output stream operator
*/
-DALI_IMPORT_API std::ostream& operator<<(std::ostream& o, const Vector4& vector);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Vector4& vector);
/**
* @brief Returns a vector with components set to the minimum of the corresponding component in a and b.
* @param[in] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_IMPORT_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 }; };
#define __DALI_ANY_TYPE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Default constructor.
* @SINCE_1_0.0
*/
- DALI_IMPORT_API Any();
+ DALI_CORE_API Any();
/**
* @brief Destructor. Free resources.
* @SINCE_1_0.0
*/
- DALI_IMPORT_API ~Any();
+ DALI_CORE_API ~Any();
/**
* @brief Passes Assert message.
* @SINCE_1_0.0
* @param[in] assertMessage Assert message to report
*/
- DALI_IMPORT_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.
* @exception DaliException If parameter any is of a different type.
*
*/
- DALI_IMPORT_API Any& operator=( const Any& any );
+ DALI_CORE_API Any& operator=( const Any& any );
/**
* @brief Gets a value of type Type from container.
* @return The std::type_info of the stored value or the type info of the void
* type if there is no value stored
*/
- DALI_IMPORT_API const std::type_info& GetType() const;
+ DALI_CORE_API const std::type_info& GetType() const;
/**
* @brief Retrieves the stored value in the Any type.
#define __DALI_BASE_HANDLE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API BaseHandle
+class DALI_CORE_API BaseHandle
{
public:
#define __DALI_BASE_OBJECT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A base class for objects.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API BaseObject : public Dali::RefObject
+class DALI_CORE_API BaseObject : public Dali::RefObject
{
public:
* @brief Dali::Handle is a handle to an internal property owning Dali object that can have constraints applied to it.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Handle : public BaseHandle
+class DALI_CORE_API Handle : public BaseHandle
{
public:
namespace WeightObject
{
-DALI_IMPORT_API extern const Property::Index WEIGHT; ///< name "weight", type FLOAT
+DALI_CORE_API extern const Property::Index WEIGHT; ///< name "weight", type FLOAT
/**
* @brief Convenience function to create an object with a custom "weight" property.
* @SINCE_1_0.0
* @return A handle to a newly allocated object
*/
-DALI_IMPORT_API Handle New();
+DALI_CORE_API Handle New();
} // namespace WeightObject
#define __DALI_OBJECT_REGISTRY_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | objectDestroyed | @ref ObjectDestroyedSignal() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API ObjectRegistry : public BaseHandle
+class DALI_CORE_API ObjectRegistry : public BaseHandle
{
public:
#define __DALI_PROPERTY_ARRAY_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A Array of property values.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Property::Array
+class DALI_CORE_API Property::Array
{
public:
* @param[in] array The array to insert
* @return The output stream operator
*/
-DALI_IMPORT_API std::ostream& operator<<( std::ostream& stream, const Property::Array& array );
+DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Array& array );
/**
* @}
#define __DALI_PROPERTY_CONDITIONS_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief This represents a condition that can be evaluated on a Property::Value.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API PropertyCondition : public BaseHandle
+class DALI_CORE_API PropertyCondition : public BaseHandle
{
public:
* @param[in] arg The argument for the condition
* @return A property condition function object
*/
-DALI_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_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_IMPORT_API PropertyCondition VariableStepCondition( const Dali::Vector<float>& steps );
+DALI_CORE_API PropertyCondition VariableStepCondition( const Dali::Vector<float>& steps );
/**
* @}
#define __DALI_PROPERTY_INPUT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief An abstract interface for receiving property values.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API PropertyInput
+class DALI_CORE_API PropertyInput
{
public:
#define __DALI_PROPERTY_KEY_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A key type which can be either a std::string or a Property::Index
* @SINCE_1_2.7
*/
-struct DALI_IMPORT_API Property::Key
+struct DALI_CORE_API Property::Key
{
/**
* @brief The type of key
* @param [in] key the key to convert
* @return The output stream operator.
*/
-DALI_IMPORT_API std::ostream& operator<<( std::ostream& stream, const Property::Key& key );
+DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Key& key );
/**
#define __DALI_PROPERTY_MAP_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A Map of property values, the key type could be String or Property::Index.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Property::Map
+class DALI_CORE_API Property::Map
{
public:
* @param[in] map The map to insert
* @return The output stream operator
*/
-DALI_IMPORT_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_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @SINCE_1_0.0
* @see Dali::PropertyCondition
*/
-class DALI_IMPORT_API PropertyNotification : public BaseHandle
+class DALI_CORE_API PropertyNotification : public BaseHandle
{
public:
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace PropertyTypes
{
-DALI_EXPORT_API const char* GetName(Property::Type type)
+DALI_CORE_API const char* GetName(Property::Type type)
{
if (type < PROPERTY_TYPE_NAMES_COUNT )
{
#define __DALI_PROPERTY_TYPES_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @param[in] type The property type
* @return The name of this type
*/
-DALI_IMPORT_API const char* GetName(Property::Type type);
+DALI_CORE_API const char* GetName(Property::Type type);
/**
* @brief Retrieves an enumerated property type.
#define __DALI_PROPERTY_VALUE_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief A value-type representing a property value.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API Property::Value
+class DALI_CORE_API Property::Value
{
public:
* @param[in] value The value to insert
* @return The output stream operator
*/
-DALI_IMPORT_API std::ostream& operator<<( std::ostream& ouputStream, const Property::Value& value );
+DALI_CORE_API std::ostream& operator<<( std::ostream& ouputStream, const Property::Value& value );
/**
* @}
#define __DALI_PROPERTY_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief An object + property pair.
* @SINCE_1_0.0
*/
-struct DALI_IMPORT_API Property
+struct DALI_CORE_API Property
{
/**
* @brief A valid property index is zero or greater.
#define __DALI_REF_OBJECT_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* instead of calling Reference() and Unreference() methods directly.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API RefObject
+class DALI_CORE_API RefObject
{
public:
* See TypeRegistry for methods of type registration and TypeInfo retrieval.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API TypeInfo : public BaseHandle
+class DALI_CORE_API TypeInfo : public BaseHandle
{
public:
typedef BaseHandle (*CreateFunction)(); ///< Function signature for creating an instance of the associated object type. @SINCE_1_0.0
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API TypeRegistry : public BaseHandle
+class DALI_CORE_API TypeRegistry : public BaseHandle
{
public:
/**
* @brief Registers a type from type info.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API TypeRegistration
+class DALI_CORE_API TypeRegistration
{
public:
/**
* @brief Registers a signal connector function to a registered type.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API SignalConnectorType
+class DALI_CORE_API SignalConnectorType
{
public:
/**
* @brief Registers an action function.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API TypeAction
+class DALI_CORE_API TypeAction
{
public:
/**
* @brief Registers a property for the given type.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API PropertyRegistration
+class DALI_CORE_API PropertyRegistration
{
public:
* @brief Registers an animatable property for the given type.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API AnimatablePropertyRegistration
+class DALI_CORE_API AnimatablePropertyRegistration
{
public:
* @brief Registers a component of animatable property for the given component index.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API AnimatablePropertyComponentRegistration
+class DALI_CORE_API AnimatablePropertyComponentRegistration
{
public:
* @brief Registers a child property for the given type.
* @SINCE_1_1.35
*/
-class DALI_IMPORT_API ChildPropertyRegistration
+class DALI_CORE_API ChildPropertyRegistration
{
public:
#define DALI_WEAK_HANDLE_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* deleted object will return an empty handle.
* @SINCE_1_2.60
*/
-class DALI_IMPORT_API WeakHandleBase
+class DALI_CORE_API WeakHandleBase
{
public:
#define __DALI_RENDER_TASK_LIST_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* These tasks describe how the Dali scene should be rendered; @see Dali::RenderTask for more details.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API RenderTaskList : public BaseHandle
+class DALI_CORE_API RenderTaskList : public BaseHandle
{
public:
#define __DALI_RENDER_TASK_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* | finished | @ref FinishedSignal() |
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API RenderTask : public Handle
+class DALI_CORE_API RenderTask : public Handle
{
public:
#define DALI_FRAMEBUFFER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief FrameBuffer is a collection of textures that can be used as the destination for rendering.
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API FrameBuffer : public BaseHandle
+class DALI_CORE_API FrameBuffer : public BaseHandle
{
public:
#define DALI_GEOMETRY_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API Geometry : public BaseHandle
+class DALI_CORE_API Geometry : public BaseHandle
{
public:
#define DALI_PROPERTY_BUFFER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API PropertyBuffer : public BaseHandle
+class DALI_CORE_API PropertyBuffer : public BaseHandle
{
public:
#define DALI_RENDERER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API Renderer : public Handle
+class DALI_CORE_API Renderer : public Handle
{
public:
#define DALI_SAMPLER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API Sampler : public BaseHandle
+class DALI_CORE_API Sampler : public BaseHandle
{
public:
#define DALI_SHADER_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API Shader : public Handle
+class DALI_CORE_API Shader : public Handle
{
public:
#define DALI_TEXTURE_SET_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* The images have to be ordered in the same order they are declared in the shader.
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API TextureSet : public BaseHandle
+class DALI_CORE_API TextureSet : public BaseHandle
{
public:
#define DALI_TEXTURE_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Texture represents a texture object used as input or output by shaders.
* @SINCE_1_1.43
*/
-class DALI_IMPORT_API Texture : public BaseHandle
+class DALI_CORE_API Texture : public BaseHandle
{
public:
#define __DALI_BASE_SIGNAL_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API BaseSignal : public SlotObserver
+class DALI_CORE_API BaseSignal : public SlotObserver
{
public:
#define __DALI_CALLBACK_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Callback base class to hold the data for callback function and member function calls.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API CallbackBase
+class DALI_CORE_API CallbackBase
{
public:
#define __DALI_CONNECTION_TRACKER_INTERFACE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* e.g. if Button object is destroyed while it is still connected.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API ConnectionTrackerInterface : public SignalObserver
+class DALI_CORE_API ConnectionTrackerInterface : public SignalObserver
{
public:
#define __DALI_CONNECTION_TRACKER_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Connection tracker concrete implementation.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API ConnectionTracker : public ConnectionTrackerInterface
+class DALI_CORE_API ConnectionTracker : public ConnectionTrackerInterface
{
public:
#define __DALI_FUNCTOR_DELEGATE_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* @brief Used to connect a void() functor to a signal via BaseObject::SignalConnect().
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API FunctorDelegate
+class DALI_CORE_API FunctorDelegate
{
public:
#define __DALI_SIGNAL_SLOT_CONNECTIONS_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* It holds a pointer to the callback, but does not own it.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API SlotConnection
+class DALI_CORE_API SlotConnection
{
public:
* the connection is destroyed.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API SignalConnection
+class DALI_CORE_API SignalConnection
{
public:
#define __DALI_SIGNAL_SLOT_OBSERVERS_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* This will happen if the object owning the signal is destroyed.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API SignalObserver
+class DALI_CORE_API SignalObserver
{
public:
* This is used by the slot if wants to disconnect or is deleted.
* @SINCE_1_0.0
*/
-class DALI_IMPORT_API SlotObserver
+class DALI_CORE_API SlotObserver
{
public:
projects / platform / core / uifw / dali-core.git / commitdiff