#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/touch-event.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
// INTERNAL INCLUDES
#include <dali/integration-api/events/pan-gesture-event.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
#include <dali/public-api/signals/dali-signal-v2.h>
#include <dali/public-api/events/touch-event.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief The AccessibilityManager provides signals when accessibility & screen reader feature turned on in device.
*/
-class AccessibilityManager : public BaseHandle
+class DALI_IMPORT_API AccessibilityManager : public BaseHandle
{
public:
*
* @param[in] manager The AccessibilityManager implementation.
*/
- AccessibilityManager( Internal::Adaptor::AccessibilityManager& manager );
+ DALI_INTERNAL AccessibilityManager( Internal::Adaptor::AccessibilityManager& manager );
/**
* @brief This constructor is used by AccessibilityManager::Get().
*
* @param[in] manager A pointer to the accessibility manager.
*/
- AccessibilityManager( Internal::Adaptor::AccessibilityManager* manager );
+ explicit DALI_INTERNAL AccessibilityManager( Internal::Adaptor::AccessibilityManager* manager );
};
} // namespace Dali
#include "device-layout.h"
#include "window.h"
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* When the above options are found, they are stripped from argv, and argc is updated appropriately.
*/
-class Application : public BaseHandle
+class DALI_IMPORT_API Application : public BaseHandle
{
public:
class BitmapLoader;
}
-class BitmapLoader : public BaseHandle
+class DALI_IMPORT_API BitmapLoader : public BaseHandle
{
public:
/**
*
* @return true if the file was saved
*/
-bool EncodeToFile(const unsigned char* const pixelBuffer,
- const std::string& filename,
- const Pixel::Format pixelFormat,
- const std::size_t width,
- const std::size_t height);
-
+DALI_IMPORT_API bool EncodeToFile(const unsigned char* const pixelBuffer,
+ const std::string& filename,
+ const Pixel::Format pixelFormat,
+ const std::size_t width,
+ const std::size_t height);
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief The ClipboardEventNotifier provides signals when clipboard events are received from the device.
*/
-class ClipboardEventNotifier : public BaseHandle
+class DALI_IMPORT_API ClipboardEventNotifier : public BaseHandle
{
public:
*
* @param[in] notifier A pointer to the drag and drop notifier.
*/
- ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
+ explicit DALI_INTERNAL ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
};
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* Clipboard can manage it's item and set show / hide status.
*/
-class Clipboard : public BaseHandle
+class DALI_IMPORT_API Clipboard : public BaseHandle
{
public:
/**
*
* @param[in] clipboard A pointer to the clipboard.
*/
- Clipboard( Internal::Adaptor::Clipboard* clipboard );
+ explicit DALI_INTERNAL Clipboard( Internal::Adaptor::Clipboard* clipboard );
/**
* @brief Retrieve a handle to the ClipboardEventNotifier instance.
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* It provides the functionality of retrieving a RGBA color by passing in the color code string.
*/
-class ColorController : public BaseHandle
+class DALI_IMPORT_API ColorController : public BaseHandle
{
public:
// EXTERNAL INCLUDES
#include <dali/public-api/math/vector2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @see Dali::Application::Application(* argc, char **argv[], DeviceLayout baseLayout)
* @see Dali::Adaptor::Adaptor(RenderSurface& surface, DeviceLayout baseLayout)
*/
-struct DeviceLayout
+struct DALI_IMPORT_API DeviceLayout
{
public: // Construction & Destruction
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @endcode
*/
-class DragAndDropDetector : public BaseHandle
+class DALI_IMPORT_API DragAndDropDetector : public BaseHandle
{
public:
*
* @param[in] detector A pointer to the drag and drop detector.
*/
- DragAndDropDetector( Internal::Adaptor::DragAndDropDetector* detector );
+ explicit DALI_INTERNAL DragAndDropDetector( Internal::Adaptor::DragAndDropDetector* detector );
};
} // namespace Dali
// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
struct KeyEvent;
*
* @note For testing/automation purposes only.
*/
-void FeedTouchPoint( TouchPoint& point, int timeStamp );
+DALI_IMPORT_API void FeedTouchPoint( TouchPoint& point, int timeStamp );
/**
* Feed a mouse wheel event to the adaptor.
*
* @note For testing/automation purposes only.
*/
-void FeedWheelEvent( MouseWheelEvent& wheelEvent );
+DALI_IMPORT_API void FeedWheelEvent( MouseWheelEvent& wheelEvent );
/**
* Feed a key event to the adaptor.
*
* @note For testing/automation purposes only.
*/
-void FeedKeyEvent( KeyEvent& keyEvent );
+DALI_IMPORT_API void FeedKeyEvent( KeyEvent& keyEvent );
} // namespace EventFeeder
// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief Plays haptic effects.
*/
-class HapticPlayer : public BaseHandle
+class DALI_IMPORT_API HapticPlayer : public BaseHandle
{
public:
* @brief This constructor is used by HapticPlayer::Get().
* @param[in] hapticPlayer A pointer to the haptic player.
*/
- HapticPlayer( Internal::Adaptor::HapticPlayer* hapticPlayer );
+ explicit DALI_INTERNAL HapticPlayer( Internal::Adaptor::HapticPlayer* hapticPlayer );
};
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* Specifically manages the ecore input method framework which enables the virtual or hardware keyboards.
*/
-class ImfManager : public BaseHandle
+class DALI_IMPORT_API ImfManager : public BaseHandle
{
public:
*
* @param[in] imfManager A pointer to the imf Manager.
*/
- ImfManager( Internal::Adaptor::ImfManager* imfManager );
+ explicit DALI_INTERNAL ImfManager( Internal::Adaptor::ImfManager* imfManager );
};
} // namespace Dali
#include <dali/public-api/signals/dali-signal-v2.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* Dali applications have full control over visual layout when the device is rotated
* i.e. the application developer decides which UI controls to rotate, if any.
*/
-class Orientation : public BaseHandle
+class DALI_IMPORT_API Orientation : public BaseHandle
{
public:
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* This is a handle to a physical keyboard connected to the device.
*/
-class PhysicalKeyboard : public BaseHandle
+class DALI_IMPORT_API PhysicalKeyboard : public BaseHandle
{
public:
#include <dali/public-api/images/native-image.h>
#include <dali/public-api/object/any.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
class Adaptor;
* externally by X11 or ECORE-X11.
*
*/
-class PixmapImage : public NativeImage
+class DALI_IMPORT_API PixmapImage : public NativeImage
{
public:
* @param[in] adaptor a reference to Dali adaptor
* @param[in] pixmap contains either: pixmap of type X11 Pixmap , a Ecore_X_Pixmap or is empty
*/
- PixmapImage(unsigned int width, unsigned int height, ColorDepth depth, Adaptor& adaptor, Any pixmap);
+ DALI_INTERNAL PixmapImage(unsigned int width, unsigned int height, ColorDepth depth, Adaptor& adaptor, Any pixmap);
/**
* @brief A reference counted object may only be deleted by calling Unreference().
*
* The implementation should destroy the NativeImage resources.
*/
- virtual ~PixmapImage();
+ DALI_INTERNAL virtual ~PixmapImage();
/**
* @brief Undefined assignment operator.
* This avoids accidental calls to a default assignment operator.
* @param[in] rhs A reference to the object to copy.
*/
- PixmapImage& operator=(const PixmapImage& rhs);
+ DALI_INTERNAL PixmapImage& operator=(const PixmapImage& rhs);
private:
#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/any.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* @param [in] name optional name of surface passed in
* @return The render surface
*/
-RenderSurface* CreateDefaultSurface( RenderSurface::SurfaceType type, PositionSize positionSize, const std::string& name = "" );
+DALI_IMPORT_API RenderSurface* CreateDefaultSurface( RenderSurface::SurfaceType type, PositionSize positionSize, const std::string& name = "" );
} // namespace Dali
// INTERNAL INCLUDES
#include <singleton-service-impl.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
SingletonService::SingletonService()
#include <typeinfo>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @see Application
*/
-class SingletonService : public BaseHandle
+class DALI_IMPORT_API SingletonService : public BaseHandle
{
public:
* @brief This constructor is used by SingletonService::Get().
* @param[in] singletonService A pointer to the internal singleton-service object.
*/
- SingletonService( Internal::Adaptor::SingletonService* singletonService );
+ explicit DALI_INTERNAL SingletonService( Internal::Adaptor::SingletonService* singletonService );
};
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief Plays sound effects.
*/
-class SoundPlayer : public BaseHandle
+class DALI_IMPORT_API SoundPlayer : public BaseHandle
{
public:
*
* @param[in] soundPlayer A pointer to the sound player.
*/
- SoundPlayer( Internal::Adaptor::SoundPlayer* soundPlayer );
+ explicit DALI_INTERNAL SoundPlayer( Internal::Adaptor::SoundPlayer* soundPlayer );
};
} // namespace Dali
// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
* This structure is used when any style changes occur and contains information about what exactly
* has changed.
*/
-struct StyleChange
+struct DALI_IMPORT_API StyleChange
{
// Data
// INTERNAL INCLUDES
#include "style-change.h"
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* It provides a signal when any aspect of the default style changes on the device.
* @see Adaptor::GetStyleMonitor
*/
-class StyleMonitor : public BaseHandle
+class DALI_IMPORT_API StyleMonitor : public BaseHandle
{
public: // Typedefs
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
*
* @endcode
*/
-class TiltSensor : public BaseHandle
+class DALI_IMPORT_API TiltSensor : public BaseHandle
{
public:
* This constructor is used by TiltSensor::Get().
* @param[in] sensor A pointer to the tilt sensor.
*/
- TiltSensor( Internal::Adaptor::TiltSensor* sensor );
+ explicit DALI_INTERNAL TiltSensor( Internal::Adaptor::TiltSensor* sensor );
};
} // namespace Dali
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/dali-signal-v2.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
* This class is a handle class so it can be stack allocated and used
* as a member.
*/
-class Timer : public BaseHandle
+class DALI_IMPORT_API Timer : public BaseHandle
{
public: // Signal typedefs
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
namespace Internal DALI_INTERNAL
/**
* @brief The Text-to-speech Player.
*/
-class TtsPlayer : public BaseHandle
+class DALI_IMPORT_API TtsPlayer : public BaseHandle
{
public: // ENUMs
* @brief This constructor is used by TtsPlayer::Get().
* @param[in] ttsPlayer A pointer to the TTS player.
*/
- TtsPlayer( Internal::Adaptor::TtsPlayer* ttsPlayer );
+ explicit DALI_INTERNAL TtsPlayer( Internal::Adaptor::TtsPlayer* ttsPlayer );
};
} // namespace Dali
#include <dali/public-api/signals/dali-signal-v2.h>
#include <dali/public-api/math/rect.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
/**
/**
* @brief Show the virtual keyboard.
*/
-void Show();
+DALI_IMPORT_API void Show();
/**
* @brief Hide the virtual keyboard.
*/
-void Hide();
+DALI_IMPORT_API void Hide();
/**
* @brief Returns whether the virtual keyboard is visible or not.
* @return true if visible, false otherwise.
*/
-bool IsVisible();
+DALI_IMPORT_API bool IsVisible();
/**
* @brief Set the specific return key into the virtual keyboard.
* @param[in] type the kind of return key types.
*/
-void SetReturnKeyType( ReturnKeyType type );
+DALI_IMPORT_API void SetReturnKeyType( ReturnKeyType type );
/**
* @brief Retrieve the current return key type.
* @return the type of retun key.
*/
-ReturnKeyType GetReturnKeyType();
+DALI_IMPORT_API ReturnKeyType GetReturnKeyType();
/**
* @brief Enable/disable prediction (predictive text).
* @param[in] enable true or false to enable or disable
* Prediction can not be changed while the keyboard is visible. It must be set in advance of showing keyboard.
*/
-void EnablePrediction(const bool enable);
+DALI_IMPORT_API void EnablePrediction(const bool enable);
/**
* @brief Returns whether prediction is enabled in the virtual keyboard
* @return true if predictive text enabled, false otherwise.
*/
-bool IsPredictionEnabled();
+DALI_IMPORT_API bool IsPredictionEnabled();
/**
* @brief Provides size and position of keyboard.
* the values then taken down. So ideally GetSizeAndPosition() should be called after Show().
* @return rect which is keyboard panel x, y, width, height
*/
-Dali::Rect<int> GetSizeAndPosition();
+DALI_IMPORT_API Dali::Rect<int> GetSizeAndPosition();
/**
* @brief Rotates the keyboard orientation to the given angle.
* Other valid values are 90, 180, 270.
* @param angle the angle is in degrees.
*/
-void RotateTo(int angle);
+DALI_IMPORT_API void RotateTo(int angle);
/**
* @brief Returns text direction of the keyboard's current input language.
* @return The direction of the text.
*/
-TextDirection GetTextDirection();
+DALI_IMPORT_API TextDirection GetTextDirection();
/**
* @brief Connect to this signal to be notified when the virtual keyboard is shown or hidden.
* has just been hidden.
* @return The signal to connect to.
*/
-StatusSignalV2& StatusChangedSignal();
+DALI_IMPORT_API StatusSignalV2& StatusChangedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard is resized.
* User can get changed size by using GetSizeAndPosition() in the callback
* @return The signal to connect to.
*/
-VoidSignalV2& ResizedSignal();
+DALI_IMPORT_API VoidSignalV2& ResizedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard's language is changed.
* User can get the text direction of the language by calling GetTextDirection() in the callback.
* @return The signal to connect to.
*/
-VoidSignalV2& LanguageChangedSignal();
+DALI_IMPORT_API VoidSignalV2& LanguageChangedSignal();
} // namespace VirtualKeyboard
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/object/base-handle.h>
-namespace Dali DALI_IMPORT_API
+namespace Dali
{
typedef Dali::Rect<int> PositionSize;
* It has an orientation
* and indicator properties.
*/
-class Window : public BaseHandle
+class DALI_IMPORT_API Window : public BaseHandle
{
public:
* @brief This constructor is used by Dali::Application::GetWindow().
* @param[in] window A pointer to the window.
*/
- explicit Window( Internal::Adaptor::Window* window );
+ explicit DALI_INTERNAL Window( Internal::Adaptor::Window* window );
};
} // namespace Dali
*
*/
+// EXTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+
namespace Dali
{
-extern const unsigned int ADAPTOR_MAJOR_VERSION; ///< The major version number of the Adaptor.
-extern const unsigned int ADAPTOR_MINOR_VERSION; ///< The minor version number of the Adaptor.
-extern const unsigned int ADAPTOR_MICRO_VERSION; ///< The micro version number of the Adaptor.
-extern const char * const ADAPTOR_BUILD_DATE; ///< The date/time the Adaptor library was built.
+DALI_IMPORT_API extern const unsigned int ADAPTOR_MAJOR_VERSION; ///< The major version number of the Adaptor.
+DALI_IMPORT_API extern const unsigned int ADAPTOR_MINOR_VERSION; ///< The minor version number of the Adaptor.
+DALI_IMPORT_API extern const unsigned int ADAPTOR_MICRO_VERSION; ///< The micro version number of the Adaptor.
+DALI_IMPORT_API extern const char * const ADAPTOR_BUILD_DATE; ///< The date/time the Adaptor library was built.
} // namespace Dali
#endif // __DALI_ADAPTOR_VERSION_H__
/**
* @copydoc Dali::Integration::Log:LogMessage
*/
-DALI_IMPORT_API void LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message);
+void LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message);
} // namespace SlpPlatform
namespace Dali
{
-DALI_IMPORT_API Integration::PlatformAbstraction* CreatePlatformAbstraction()
+Integration::PlatformAbstraction* CreatePlatformAbstraction()
{
return new SlpPlatform::SlpPlatformAbstraction();
}
/**
* Construct a platform abstraction and return it.
*/
-DALI_IMPORT_API Integration::PlatformAbstraction* CreatePlatformAbstraction();
+Integration::PlatformAbstraction* CreatePlatformAbstraction();
namespace SlpPlatform
{
projects / platform / core / uifw / dali-adaptor.git / commitdiff