--- /dev/null
+#ifndef __DALI_DOC_H__
+#define __DALI_DOC_H__
+
+//
+// Copyright (c) 2014 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Flora License, Version 1.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://floralicense.org/license/
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an AS IS BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+/**
+ * @ingroup CAPI_DALI_MODULE
+ * @defgroup CAPI_DALI_ADAPTOR_MODULE Adaptor Framework
+ * @section CAPI_DALI_ADAPTOR_MODULE_HEADER Required Header
+ * \#include <dali/dali.h>
+ * @section CAPI_DALI_ADAPTOR_MODULE_OVERVIEW Overview
+ * The adaptor framework provides interfaces onto the platform for Dali.
+ * <table> <tr><th>API</th><th>Description</th></tr>
+ * <tr><td>@ref Dali::EvasPlugin </td><td>Used by EFL applications that wish to use Dali.</td></tr>
+ * <tr><td>@ref Dali::NativeBufferPlugin </td><td>Used by Tizen applications that wish to capture Dali output in a buffer.</td></tr>
+ * <tr><td>@ref Dali::AccessibilityManager </td><td>Provides signals for accessibility and screen reader.</td></tr>
+ * <tr><td>@ref Dali::Adaptor </td><td>An Adaptor object is used to initialize and control how Dali runs.</td></tr>
+ * <tr><td>@ref Dali::ClipboardEventNotifier </td><td>Provides signals when clipboard events are received from the device.</td></tr>
+ * <tr><td>@ref Dali::Clipboard </td><td>Interface to the device's clipboard.</td></tr>
+ * <tr><td>@ref Dali::DeviceLayout </td><td> The attributes of the screen on the device.</td></tr>
+ * <tr><td>@ref Dali::DragAndDropDetector </td><td>The DragAndDropDetector s provides signals when draggable objects are dragged into the Dali window.</td></tr>
+ * <tr><td>@ref Dali::HapticPlayer </td><td></td>Plays haptic effects.</tr>
+ * <tr><td>@ref Dali::ImfManager </td><td>Interface to the device's Input framework.</td></tr>
+ * <tr><td>@ref Dali::Orientation </td><td>Determines the device orientation.</td></tr>
+ * <tr><td>@ref Dali::PixmapImage </td><td>Used for displaying native Pixmap images.</td></tr>
+ * <tr><td>@ref Dali::RenderSurface </td><td>Interface for a render surface onto which Dali draws.</td></tr>
+ * <tr><td>@ref Dali::SoundPlayer </td><td>Class for playing sound effects.</td></tr>
+ * <tr><td>@ref Dali::StyleChange </td><td>Class for describing what style information has changed.</td></tr>
+ * <tr><td>@ref Dali::StyleMonitor </td><td>Monitors the platform for style changes.</td></tr>
+ * <tr><td>@ref Dali::Timer </td><td>Mechanism to issue simple periodic or one-shot events.</td></tr>
+ * <tr><td>@ref Dali::TtsPlayer </td><td>Interface to the Text-to-Speech player.</td></tr>
+ * <tr><td>@ref Dali::VirtualKeyboard </td><td>Interface to the virtual keyboard.</td></tr>
+ * <tr><td>@ref Dali::Window </td><td>The Window class is used for drawing Dali.</td></tr>
+ * </table>
+ */
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
class TouchPoint;
/**
- * The AccessibilityManager provides signals when accessibility & screen reader feature turned on in device.
+ * @brief The AccessibilityManager provides signals when accessibility & screen reader feature turned on in device.
*/
class AccessibilityManager : public BaseHandle
{
// Typedefs
/**
- * Accessibility Action Signal
+ * @brief Accessibility Action Signal.
+ *
* Signal connected callback should return the result
*/
- typedef SignalV2< bool ( AccessibilityManager& ) > AccessibilityActionSignalV2;
+ typedef SignalV2< bool ( AccessibilityManager& ) > AccessibilityActionSignalV2; ///< Generic signal type
// Signal Names
- static const char* const SIGNAL_STATUS_CHANGED;
- static const char* const SIGNAL_ACTION_NEXT;
- static const char* const SIGNAL_ACTION_PREVIOUS;
- static const char* const SIGNAL_ACTION_ACTIVATE;
- static const char* const SIGNAL_ACTION_OVER;
- static const char* const SIGNAL_ACTION_READ;
- static const char* const SIGNAL_ACTION_READ_NEXT;
- static const char* const SIGNAL_ACTION_READ_PREVIOUS;
- static const char* const SIGNAL_ACTION_UP;
- static const char* const SIGNAL_ACTION_DOWN;
- static const char* const SIGNAL_ACTION_CLEAR_FOCUS;
- static const char* const SIGNAL_ACTION_BACK;
-
- /**
- * Create an uninitialized handle.
+ static const char* const SIGNAL_STATUS_CHANGED; ///< name "accessibility-status-changed"
+ static const char* const SIGNAL_ACTION_NEXT; ///< name "accessibility-action-next"
+ static const char* const SIGNAL_ACTION_PREVIOUS; ///< name "accessibility-action-previous"
+ static const char* const SIGNAL_ACTION_ACTIVATE; ///< name "accessibility-action-activatae"
+ static const char* const SIGNAL_ACTION_OVER; ///< name "accessibility-action-over"
+ static const char* const SIGNAL_ACTION_READ; ///< name "accessibility-action-read"
+ static const char* const SIGNAL_ACTION_READ_NEXT; ///< name "accessibility-action-read-next"
+ static const char* const SIGNAL_ACTION_READ_PREVIOUS; ///< name "accessibility-action-read-prev"
+ static const char* const SIGNAL_ACTION_UP; ///< name "accessibility-action-up"
+ static const char* const SIGNAL_ACTION_DOWN; ///< name "accessibility-action-down"
+ static const char* const SIGNAL_ACTION_CLEAR_FOCUS; ///< name "accessibility-action-clear-focus"
+ static const char* const SIGNAL_ACTION_BACK; ///< name "accessibility-action-back"
+
+ /**
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by calling getting the manager from Dali::Adaptor.
*/
AccessibilityManager();
/**
- * Retrieve a handle to the AccessibilityManager.
+ * @brief Retrieve a handle to the AccessibilityManager.
+ *
* @return A handle to the AccessibilityManager.
*/
static AccessibilityManager Get();
/**
- * Virtual Destructor.
+ * @brief Virtual Destructor.
*/
virtual ~AccessibilityManager();
/**
- * Returns the current position of the read action.
+ * @brief Returns the current position of the read action.
* @return The current event position.
*/
Vector2 GetReadPosition() const;
/**
- * Query whether the accessibility(screen-reader) is enabled.
+ * @brief Query whether the accessibility(screen-reader) is enabled.
+ *
* The accessibility will be enabled by system setting.
* @return True if the accessibility(screen-reader) is enabled.
*/
bool IsEnabled() const;
/**
- * Set the handler to handle accessibility actions.
+ * @brief Set the handler to handle accessibility actions.
+ *
* @param[in] handler The Accessibility action handler.
* @note Handlers should remove themselves when they are destroyed.
*/
void SetActionHandler(AccessibilityActionHandler& handler);
/**
- * Set the handler to handle accessibility gestures.
+ * @brief Set the handler to handle accessibility gestures.
+ *
* @param[in] handler The Accessibility gesture handler.
* @note Handlers should remove themselves when they are destroyed.
*/
void SetGestureHandler(AccessibilityGestureHandler& handler);
/**
- * Handle the accessibility action to move focus to the next focusable actor
+ * @brief Handle the accessibility action to move focus to the next focusable actor
* (by one finger flick down).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionNextEvent();
/**
- * Handle the accessibility action to move focus to the previous focusable actor
+ * @brief Handle the accessibility action to move focus to the previous focusable actor
* (by one finger flick up).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionPreviousEvent();
/**
- * Handle the accessibility action to activate the current focused actor (by one
+ * @brief Handle the accessibility action to activate the current focused actor (by one
* finger double tap)
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionActivateEvent();
/**
- * Handle the accessibility action to focus and read the actor (by one finger tap or move).
+ * @brief Handle the accessibility action to focus and read the actor (by one finger tap or move).
+ *
* @param x x position of event
* @param y y position of event
* @param allowReadAgain true if the action read again the same object (i.e. read action)
bool HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain);
/**
- * Handle the accessibility action to move focus to the next focusable actor
+ * @brief Handle the accessibility action to move focus to the next focusable actor
* (by one finger flick right).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionReadNextEvent();
/**
- * Handle the accessibility action to move focus to the previous focusable actor
+ * @brief Handle the accessibility action to move focus to the previous focusable actor
* (by one finger flick up).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionReadPreviousEvent();
/**
- * Handle the accessibility action to change the value when the current focused
+ * @brief Handle the accessibility action to change the value when the current focused
* actor is a slider (by double finger down and move up and right).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionUpEvent();
/**
- * Handle the accessibility action to change the value when the current focused
+ * @brief Handle the accessibility action to change the value when the current focused
* actor is a slider (by double finger down and move down and left).
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionDownEvent();
/**
- * Handle the accessibility action to clear the focus from the current focused
+ * @brief Handle the accessibility action to clear the focus from the current focused
* actor if any, so that no actor is focused in the focus chain.
+ *
* @return Whether the action is performed successfully or not.
*/
bool HandleActionClearFocusEvent();
/**
- * Handle the accessibility action to scroll when the current focused actor is
+ * @brief Handle the accessibility action to scroll when the current focused actor is
* a scrollable control or its child (by 2 finger touch & move, 2 finger flick).
+ *
* @param[in] point The touch point information.
* @param[in] timeStamp The time the touch occurred.
* @return Whether the action is performed successfully or not.
bool HandleActionScrollEvent(TouchPoint& point, unsigned long timeStamp);
/**
- * Handle the accessibility action to navigate back (by two fingers circle draw).
+ * @brief Handle the accessibility action to navigate back (by two fingers circle draw).
* @return Whether the action is performed successfully or not.
*/
bool HandleActionBackEvent();
/**
- * Handle the accessibility action to enable the feature
+ * @brief Handle the accessibility action to enable the feature.
*/
void HandleActionEnableEvent();
/**
- * Handle the accessibility action to disable the feature
+ * @brief Handle the accessibility action to disable the feature.
*/
void HandleActionDisableEvent();
public: // Signals
/**
- * This is emitted when accessibility(screen-reader) feature turned on or off
+ * @brief This is emitted when accessibility(screen-reader) feature turned on or off.
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& StatusChangedSignal();
/**
- * This is emitted when accessibility action is received to move focus to the next
+ * @brief This is emitted when accessibility action is received to move focus to the next
* focusable actor (by one finger flick down).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionNextSignal();
/**
- * This is emitted when accessibility action is received to move focus to the previous
+ * @brief This is emitted when accessibility action is received to move focus to the previous
* focusable actor (by one finger flick up).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionPreviousSignal();
/**
- * This is emitted when accessibility action is received to activate the current focused
- * actor (by one finger double tap)
+ * @brief This is emitted when accessibility action is received to activate the current focused
+ * actor (by one finger double tap).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionActivateSignal();
/**
- * This is emitted when accessibility action is received to focus and read the actor
+ * @brief This is emitted when accessibility action is received to focus and read the actor
* (by one finger tap).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionReadSignal();
/**
- * This is emitted when accessibility action is received to focus and read the actor
+ * @brief This is emitted when accessibility action is received to focus and read the actor
* (by one finger move).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionOverSignal();
/**
- * This is emitted when accessibility action is received to move focus to the next
+ * @brief This is emitted when accessibility action is received to move focus to the next
* focusable actor (by one finger flick right).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionReadNextSignal();
/**
- * This is emitted when accessibility action is received to move focus to the previous
+ * @brief This is emitted when accessibility action is received to move focus to the previous
* focusable actor (by one finger flick left).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionReadPreviousSignal();
/**
- * This is emitted when accessibility action is received to change the value when the
+ * @brief This is emitted when accessibility action is received to change the value when the
* current focused actor is a slider (by double finger down and move up and right).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionUpSignal();
/**
- * This is emitted when accessibility action is received to change the value when the
+ * @brief This is emitted when accessibility action is received to change the value when the
* current focused actor is a slider (by double finger down and move down and left).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionDownSignal();
/**
- * This is emitted when accessibility action is received to clear the focus from the
+ * @brief This is emitted when accessibility action is received to clear the focus from the
* current focused actor if any, so that no actor is focused in the focus chain.
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
AccessibilityActionSignalV2& ActionClearFocusSignal();
/**
- * This is emitted when accessibility action is received to navigate back (by two
+ * @brief This is emitted when accessibility action is received to navigate back (by two
* fingers circle draw).
+ *
* A callback of the following type may be connected:
* @code
* bool YourCallback( AccessibilityManager& manager );
public: // Not intended for application developers
/**
- * Creates a handle using the Adaptor::Internal implementation.
+ * @brief Creates a handle using the Adaptor::Internal implementation.
+ *
* @param[in] manager The AccessibilityManager implementation.
*/
AccessibilityManager( Internal::Adaptor::AccessibilityManager& manager );
/**
- * This constructor is used by AccessibilityManager::Get().
+ * @brief This constructor is used by AccessibilityManager::Get().
+ *
* @param[in] manager A pointer to the accessibility manager.
*/
AccessibilityManager( Internal::Adaptor::AccessibilityManager* manager );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * An Adaptor object can be used as an alternative to the Dali::Application class if finer grained
- * control is required. This will allow the application writer to provide their own main loop and
- * other platform related features.
+ * @brief An Adaptor object is used to initialize and control how Dali runs.
+ *
+ * It provides a lifecycle interface that allows the application
+ * writer to provide their own main loop and other platform related
+ * features.
*
* The Adaptor class provides a means for initialising the resources required by the Dali::Core.
*
{
public:
- typedef SignalV2< void (Adaptor&) > AdaptorSignalV2;
+ typedef SignalV2< void (Adaptor&) > AdaptorSignalV2; ///< Generic Type for adaptor signals
public:
/**
- * Create a new adaptor using the window.
+ * @brief Create a new adaptor using the window.
+ *
* @param[in] window The window to draw onto
* @note The default base layout DeviceLayout::DEFAULT_BASE_LAYOUT will be used.
+ * @return a reference to the adaptor handle
*/
static Adaptor& New( Window window );
/**
- * Create a new adaptor using the window.
+ * @brief Create a new adaptor using the window.
+ *
* @param[in] window The window to draw onto
- * @param baseLayout The base layout that the application has been written for
+ * @param[in] baseLayout The base layout that the application has been written for
+ * @return a reference to the adaptor handle
*/
static Adaptor& New( Window window, const DeviceLayout& baseLayout );
/**
- * Virtual Destructor
+ * @brief Virtual Destructor.
*/
virtual ~Adaptor();
public:
/**
- * Starts the Adaptor.
+ * @brief Starts the Adaptor.
*/
void Start();
/**
- * Pauses the Adaptor.
+ * @brief Pauses the Adaptor.
*/
void Pause();
/**
- * Resumes the Adaptor, if previously paused.
+ * @brief Resumes the Adaptor, if previously paused.
+ *
* @note If the adaptor is not paused, this does not do anything.
*/
void Resume();
/**
- * Stops the Adaptor.
+ * @brief Stops the Adaptor.
*/
void Stop();
/**
- * Ensures that the function passed in is called from the main loop when it is idle.
+ * @brief Ensures that the function passed in is called from the main loop when it is idle.
*
* A callback of the following type may be used:
* @code
bool AddIdle( boost::function<void(void)> callBack );
/**
- * Get the render surface is using to render to.
+ * @brief Get the render surface the adaptor is using to render to.
+ *
* @return reference to current render surface
*/
RenderSurface& GetSurface();
/**
- * Returns a reference to the instance of the adaptor used by the current thread.
+ * @brief Returns a reference to the instance of the adaptor used by the current thread.
+ *
* @return A reference to the adaptor.
* @pre The adaptor has been initialised.
* @note This is only valid in the main thread.
static Adaptor& Get();
/**
- * Checks whether the adaptor is available.
+ * @brief Checks whether the adaptor is available.
+ *
* @return true, if it is available, false otherwise.
*/
static bool IsAvailable();
/**
- * Registers the singleton of Dali handle with its type info. The singleton will be kept
- * alive for the life time of the adaptor.
+ * @brief Registers the singleton of Dali handle with its type info.
+ *
+ * The singleton will be kept alive for the life time of the
+ * adaptor.
* @note This is not intended for application developers.
* @param[in] info The type info of the Dali handle generated by the compiler.
* @param[in] singleton The Dali handle to be registered
void RegisterSingleton(const std::type_info& info, BaseHandle singleton);
/**
- * Gets the singleton for the given type.
+ * @brief Gets the singleton for the given type.
+ *
* @note This is not intended for application developers.
* @param[in] info The type info of the given type.
* @return the Dali handle if it is registered as a singleton or an uninitialized handle.
BaseHandle GetSingleton(const std::type_info& info) const;
/**
- * Call this method to notify Dali when the system language changes.
+ * @brief Call this method to notify Dali when the system language changes.
*
* Use this only when NOT using Dali::Application, As Application created using
* Dali::Application will automatically receive notification of language change.
* When Dali::Application is not used, the application developer should
* use app-core to receive language change notifications and should update Dali
* by calling this method.
- *
*/
void NotifyLanguageChanged();
public: // Signals
/**
- * The user should connect to this signal if they need to perform any
+ * @brief The user should connect to this signal if they need to perform any
* special activities when the surface Dali is being rendered on is resized.
+ *
+ * @return The signal to connect to
*/
- AdaptorSignalV2& ResizedSignal();
+ AdaptorSignalV2& ResizedSignal();
- /**
- * This signal is emitted when the language is changed on the device.
- */
- AdaptorSignalV2& LanguageChangedSignal();
+ /**
+ * @brief This signal is emitted when the language is changed on the device.
+ *
+ * @return The signal to connect to
+ */
+ AdaptorSignalV2& LanguageChangedSignal();
private:
- // Undefined
- Adaptor(const Adaptor&);
- Adaptor& operator=(Adaptor&);
+ // Undefined
+ Adaptor(const Adaptor&);
+ Adaptor& operator=(Adaptor&);
private:
/**
- * Create an uninitialized Adaptor.
+ * @brief Create an uninitialized Adaptor.
*/
DALI_INTERNAL Adaptor();
- Internal::Adaptor::Adaptor* mImpl;
+ Internal::Adaptor::Adaptor* mImpl; ///< Implementation object
friend class Internal::Adaptor::Adaptor;
};
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * The ClipboardEventNotifier provides signals when clipboard events are received from the device.
+ * @brief The ClipboardEventNotifier provides signals when clipboard events are received from the device.
*/
class ClipboardEventNotifier : public BaseHandle
{
// Typedefs
- // Clipboard event
+ /**
+ * @brief Clipboard event
+ */
typedef SignalV2< void ( ClipboardEventNotifier& ) > ClipboardEventSignalV2;
// Signal Names
- static const char* const SIGNAL_CONTENT_SELECTED;
+ static const char* const SIGNAL_CONTENT_SELECTED; ///< name "content-selected"
/**
- * Create an uninitialized handle.
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by getting the notifier from Dali::Adaptor.
*/
ClipboardEventNotifier();
/**
- * Retrieve a handle to the ClipboardEventNotifier instance.
+ * @brief Retrieve a handle to the ClipboardEventNotifier instance.
+ *
* @return A handle to the ClipboardEventNotifier
*/
static ClipboardEventNotifier Get();
/**
- * Virtual Destructor.
+ * @brief Virtual Destructor.
*/
virtual ~ClipboardEventNotifier();
/**
- * Returns the selected content.
+ * @brief Returns the selected content.
* @return A reference to the string representing the selected content.
*/
const std::string& GetContent() const;
/**
- * Sets the selected content.
+ * @brief Sets the selected content.
* @param[in] content A string that represents the content that has been selected.
*/
void SetContent( const std::string& content );
/**
- * Clears the stored content.
+ * @brief Clears the stored content.
*/
void ClearContent();
/**
- * Called when content is selected in the clipboard.
+ * @brief Called when content is selected in the clipboard.
*/
void EmitContentSelectedSignal();
public: // Signals
/**
- * This is emitted when content is selected from the clipboard
+ * @brief This is emitted when content is selected from the clipboard.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallback( ClipboardEventNotifier& notifier );
public: // Not intended for application developers
/**
- * This constructor is used by ClipboardEventNotifier::Get().
+ * @brief This constructor is used by ClipboardEventNotifier::Get().
+ *
* @param[in] notifier A pointer to the drag and drop notifier.
*/
ClipboardEventNotifier( Internal::Adaptor::ClipboardEventNotifier* notifier );
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * The Clipboard can operate using various funtion.
+ * @brief Interface to the device's clipboard.
+ *
* Clipboard can manage it's item and set show / hide status.
*/
{
public:
/**
- * Create an uninitialized Clipboard;
- * this can be initialized with one of the derived Clipboard' New() methods
+ * @brief Create an uninitialized Clipboard.
+ *
+ * this can be initialized with one of the derived Clipboard' New() methods
*/
Clipboard();
/**
- * Virtual destructor.
+ * @brief Virtual destructor.
*/
virtual ~Clipboard();
/**
- * This constructor is used by Adaptor::GetClipboard().
+ * @brief This constructor is used by Adaptor::GetClipboard().
+ *
* @param[in] clipboard A pointer to the clipboard.
*/
Clipboard( Internal::Adaptor::Clipboard* clipboard );
/**
- * Retrieve a handle to the ClipboardEventNotifier instance
+ * @brief Retrieve a handle to the ClipboardEventNotifier instance.
+ *
* @return A handle to the Clipboard
*/
static Clipboard Get();
/**
- * Send the given string to the clipboard
+ * @brief Send the given string to the clipboard.
+ *
* @param[in] itemData string to send to clip board
* @return bool true if the internal clip board sending was successful.
*/
bool SetItem( const std::string& itemData );
/**
- * Retreive the string at the given index in the clip board.
+ * @brief Retreive the string at the given index in the clipboard.
+ *
* @param[in] index item in clipboard list to retrieve
* @return string the text item at the current index.
*/
std::string GetItem( unsigned int index );
/**
- * Returns the number of item currently in the clipboard
+ * @brief Returns the number of item currently in the clipboard.
+ *
* @return unsigned int number of clipboard items
*/
unsigned int NumberOfItems();
/**
- * Show the clipboard window
+ * @brief Show the clipboard window.
*/
void ShowClipboard();
/**
- * Hide the clipboard window
+ * @brief Hide the clipboard window.
*/
void HideClipboard();
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
{
/**
- * The attributes of the screen on the device.
+ * @brief The attributes of the screen on the device.
+ *
* An application can specify the base layout that they used by inputting the values in this
* structure and passing it to the Application or Adaptor class.
* @see Dali::Application::Application(* argc, char **argv[], DeviceLayout baseLayout)
public: // Construction & Destruction
/**
- * Default Constructor
+ * @brief Default Constructor.
*/
DeviceLayout();
/**
- * Create a DeviceLayout with specific parameters.
+ * @brief Create a DeviceLayout with specific parameters.
* @param[in] resolution The resolution of the screen the application is based upon.
* @param[in] screenSize The size of the screen the application is based upon.
* @param[in] dpi The DPI of the screen the application is based upon.
DeviceLayout(Vector2 resolution, float screenSize, Vector2 dpi, float viewingDistance);
/**
- * Destructor
+ * @brief Destructor.
*/
~DeviceLayout();
public: // Defaults Layouts
/**
- * This is the default base layout that Dali will assume if no layout is passed in from the
+ * @brief This is the default base layout that Dali will assume if no layout is passed in from the
* application.
+ *
* Resolution: 720.0f x 1280.0f
* Screen Size: 4.65f
* DPI: 316.0f x 316.0f
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * The DragAndDropDetectors provides signals when draggable objects are dragged into our window.
+ * @brief The DragAndDropDetector%s provides signals when draggable objects are dragged into our window.
* It provides signals for when the draggable object enters our window, moves around in our window,
* leaves our window and when it is finally dropped into our window.
* The basic usage is shown below:
// Typedefs
- // Drag & Drop
+ /**
+ * @brief Drag & Drop signal.
+ */
typedef SignalV2< void ( DragAndDropDetector ) > DragAndDropSignalV2;
// Signal Names
- static const char* const SIGNAL_ENTERED;
- static const char* const SIGNAL_EXITED;
- static const char* const SIGNAL_MOVED;
- static const char* const SIGNAL_DROPPED;
+ static const char* const SIGNAL_ENTERED;///< name "drag-and-drop-entered"
+ static const char* const SIGNAL_EXITED; ///< name "drag-and-drop-exited"
+ static const char* const SIGNAL_MOVED; ///< name "drag-and-drop-moved"
+ static const char* const SIGNAL_DROPPED;///< name "drag-and-drop-dropped"
/**
- * Create an uninitialized handle.
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by calling getting the detector from Dali::Window.
*/
DragAndDropDetector();
/**
- * Virtual Destructor.
+ * @brief Virtual Destructor.
*/
virtual ~DragAndDropDetector();
/**
- * Returns the dropped content.
+ * @brief Returns the dropped content.
+ *
* @return A reference to the string representing the dropped content.
*/
const std::string& GetContent() const;
/**
- * Returns the current position of the dragged object. This is the dropped position when an object
- * is dropped.
+ * @brief Returns the current position of the dragged object.
+ *
+ * This is the dropped position when an object is dropped.
* @return The current screen position.
*/
Vector2 GetCurrentScreenPosition() const;
public: // Signals
/**
- * This is emitted when a dragged object enters a DALi window.
+ * @brief This is emitted when a dragged object enters a DALi window.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallback( DragAndDropDetector detector );
DragAndDropSignalV2& EnteredSignal();
/**
- * This is emitted when a dragged object leaves a DALi window.
+ * @brief This is emitted when a dragged object leaves a DALi window.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallback( DragAndDropDetector detector );
DragAndDropSignalV2& ExitedSignal();
/**
- * This is emitted when a dragged object is moved within the DALi window.
+ * @brief This is emitted when a dragged object is moved within the DALi window.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallback( DragAndDropDetector detector );
DragAndDropSignalV2& MovedSignal();
/**
- * This is emitted when a dragged object is dropped within a DALi window.
+ * @brief This is emitted when a dragged object is dropped within a DALi window.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallback( DragAndDropDetector detector );
public: // Not intended for application developers
/**
- * This constructor is used by DragAndDropDetector::Get().
+ * @brief This constructor is used by DragAndDropDetector::Get().
+ *
* @param[in] detector A pointer to the drag and drop detector.
*/
DragAndDropDetector( Internal::Adaptor::DragAndDropDetector* detector );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * Plays haptic effects.
+ * @brief Plays haptic effects.
*/
class HapticPlayer : public BaseHandle
{
public:
/**
- * Create an uninitialized handle.
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by calling HapticPlayer::Get().
*/
HapticPlayer();
/**
- * Create an initialized handle to the HapticPlayer.
+ * @brief Create an initialized handle to the HapticPlayer.
+ *
* @return A handle to a newly allocated Dali resource.
*/
static HapticPlayer Get();
/**
- * Destructor
+ * @brief Destructor.
*/
~HapticPlayer();
/**
- * Plays a monotone vibration.
+ * @brief Plays a monotone vibration.
* @param[in] duration The duration of the vibration.
*/
void PlayMonotone(unsigned int duration);
/**
- * Plays vibration in predefined patterns.
+ * @brief Plays vibration in predefined patterns.
* @param[in] filePath Path to the file containing the effect.
*/
void PlayFile(const std::string filePath);
/**
- * Stops the currently playing vibration effects.
+ * @brief Stops the currently playing vibration effects.
*/
void Stop();
public: // Not intended for application developers
/**
- * This constructor is used by HapticPlayer::Get().
+ * @brief This constructor is used by HapticPlayer::Get().
* @param[in] hapticPlayer A pointer to the haptic player.
*/
HapticPlayer( Internal::Adaptor::HapticPlayer* hapticPlayer );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
/**
* @brief The ImfManager class
+ *
* Specifically manages the ecore input method framework which enables the virtual or hardware keyboards.
*/
class ImfManager : public BaseHandle
{
public:
+ /**
+ * @brief Events that are generated by the IMF.
+ */
enum ImfEvent
{
- VOID,
- PREEDIT,
- COMMIT,
- DELETESURROUNDING,
- GETSURROUNDING
+ VOID, ///< No event
+ PREEDIT, ///< Pre-Edit changed
+ COMMIT, ///< Commit recieved
+ DELETESURROUNDING, ///< Event to delete a range of characters from the string
+ GETSURROUNDING ///< Event to query string and cursor position
};
/**
- * This structure is used to pass on data from the IMF regarding predictive text.
+ * @brief This structure is used to pass on data from the IMF regarding predictive text.
*/
struct ImfEventData
{
/**
- * Default Constructor.
+ * @brief Default Constructor.
*/
ImfEventData()
: eventName( VOID ),
};
/**
- * Constructor
+ * @brief Constructor
+ *
* @param[in] aEventName The name of the event from the IMF.
* @param[in] aPredictiveString The pre-edit or commit string.
* @param[in] aCursorOffset Start position from the current cursor position to start deleting characters.
}
// Data
- ImfEvent eventName; // The name of the event from the IMF.
- std::string predictiveString; // The pre-edit or commit string.
- int cursorOffset; // Start position from the current cursor position to start deleting characters.
- int numberOfChars; //number of characters to delete from the cursorOffset.
+ ImfEvent eventName; ///< The name of the event from the IMF.
+ std::string predictiveString; ///< The pre-edit or commit string.
+ int cursorOffset; ///< Start position from the current cursor position to start deleting characters.
+ int numberOfChars; ///< number of characters to delete from the cursorOffset.
};
/**
- * Data required my IMF from the callback
+ * @brief Data required by IMF from the callback
*/
struct ImfCallbackData
{
+ /**
+ * @brief Constructor
+ */
ImfCallbackData( )
: update( false ), cursorPosition( 0 ), preeditResetRequired ( false )
{
}
+ /**
+ * @brief Constructor
+ * @param[in] aUpdate True if cursor position needs to be updated
+ * @param[in] aCursorPosition new position of cursor
+ * @param[in] aCurrentText current text string
+ * @param[in] aPreeditResetRequired flag if preedit reset is required.
+ */
ImfCallbackData(bool aUpdate, int aCursorPosition, std::string aCurrentText, bool aPreeditResetRequired )
: update(aUpdate), cursorPosition(aCursorPosition), currentText( aCurrentText ), preeditResetRequired( aPreeditResetRequired )
{
}
- bool update; // if cursor position needs to be updated
- int cursorPosition; // new position of cursor
- std::string currentText; // current text string
- bool preeditResetRequired; // flag if preedit reset is required.
+ bool update; ///< if cursor position needs to be updated
+ int cursorPosition; ///< new position of cursor
+ std::string currentText; ///< current text string
+ bool preeditResetRequired; ///< flag if preedit reset is required.
};
- typedef SignalV2< void (ImfManager&) > ImfManagerSignalV2;
+ typedef SignalV2< void (ImfManager&) > ImfManagerSignalV2; ///< Keyboard actived signal
- typedef SignalV2< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalV2;
+ typedef SignalV2< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalV2; ///< keyboard events
public:
/**
- * Retrieve a handle to the instance of ImfManager.
+ * @brief Retrieve a handle to the instance of ImfManager.
* @return A handle to the ImfManager.
*/
static ImfManager Get();
/**
- * Get the current imf context.
+ * @brief Get the current imf context.
* @return current imf context.
*/
ImfContext GetContext();
/**
- * Activate the IMF.
+ * @brief Activate the IMF.
+ *
* It means that the text editing is started at somewhere.
* If the H/W keyboard isn't connected then it will show the virtual keyboard.
*/
void Activate();
/**
- * Deactivate the IMF.
+ * @brief Deactivate the IMF.
+ *
* It means that the text editing is finished at somewhere.
*/
void Deactivate();
/**
- * Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.
+ * @brief Get the restoration status, which controls if the keyboard is restored after the focus lost then regained.
+ *
* If true then keyboard will be restored (activated) after focus is regained.
* @return restoration status.
*/
bool RestoreAfterFocusLost() const;
/**
- * Set status whether the IMF has to restore the keyboard after losing focus.
+ * @brief Set status whether the IMF has to restore the keyboard after losing focus.
+ *
* @param[in] toggle True means that keyboard should be restored after focus lost and regained.
*/
void SetRestoreAferFocusLost( bool toggle );
/**
- * Send message reset the pred-edit state / imf module. Used to interupt pre-edit state maybe due to a touch input.
+ * @brief Send message reset the pred-edit state / imf module.
+ *
+ * Used to interupt pre-edit state maybe due to a touch input.
*/
void Reset();
/**
- * Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation
+ * @brief Notifies IMF context that the cursor position has changed, required for features like auto-capitalisation.
*/
void NotifyCursorPosition();
/**
- * Sets cursor position stored in VirtualKeyboard, this is required by the IMF context
+ * @brief Sets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+ *
* @param[in] cursorPosition position of cursor
*/
void SetCursorPosition( unsigned int cursorPosition );
/**
- * Gets cursor position stored in VirtualKeyboard, this is required by the IMF context
+ * @brief Gets cursor position stored in VirtualKeyboard, this is required by the IMF context.
+ *
* @return current position of cursor
*/
int GetCursorPosition();
/**
- * Method to store the string required by the IMF, this is used to provide predictive word suggestions.
+ * @brief Method to store the string required by the IMF, this is used to provide predictive word suggestions.
+ *
* @param[in] text The text string surrounding the current cursor point.
*/
void SetSurroundingText( std::string text );
/**
- * Gets current text string set within the IMF manager, this is used to offer predictive suggestions
+ * @brief Gets current text string set within the IMF manager, this is used to offer predictive suggestions.
+ *
* @return current position of cursor
*/
std::string GetSurroundingText();
// Signals
/**
- * This is emitted when the virtual keyboard is connected to or the hardware keyboard is activated.
+ * @brief This is emitted when the virtual keyboard is connected to or the hardware keyboard is activated.
+ *
* @return The IMF Activated signal.
*/
ImfManagerSignalV2& ActivatedSignal();
/**
- * This is emitted when the IMF manager receives an event from the IMF
+ * @brief This is emitted when the IMF manager receives an event from the IMF.
+ *
* @return The Event signal containing the event data.
*/
ImfEventSignalV2& EventReceivedSignal();
// Construction & Destruction
/**
- * Constructor
+ * @brief Constructor.
*/
ImfManager();
/**
- * Virtual destructor.
+ * @brief Virtual destructor.
*/
virtual ~ImfManager();
/**
- * This constructor is used by ImfManager::Get().
+ * @brief This constructor is used by ImfManager::Get().
+ *
* @param[in] imfManager A pointer to the imf Manager.
*/
ImfManager( Internal::Adaptor::ImfManager* imfManager );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
{
/**
- * Mapping of keyboard and mouse button event keycodes to platform specific codes.
+ * @brief Mapping of keyboard and mouse button event keycodes to platform specific codes.
+ *
* For tizen the X Server Keycode is used as reference, unless it's over ridden
* in utilX.h in which case the values are based on utilX.h
*/
extern const KEY DALI_KEY_VOLUME_DOWN;
/**
- * Check if a key event is for a specific DALI KEY.
+ * @brief Check if a key event is for a specific DALI KEY.
+ *
* @param keyEvent reference to a keyEvent structure
* @param daliKey dali key enum
* @return true if the key is matched, false if not
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * Orientation allows the user to determine the orientation of the device.
+ * @brief Orientation allows the user to determine the orientation of the device.
+ *
* A signal is emitted whenever the orientation changes.
* 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.
{
public:
- typedef SignalV2< void (Orientation) > OrientationSignalV2;
+ typedef SignalV2< void (Orientation) > OrientationSignalV2; ///< Orientation changed signal type
/**
- * Create an unintialized handle. This can be initialized by calling
- * Dali::Application::GetOrientation()
+ * @brief Create an unintialized handle.
+ *
+ * This can be initialized by calling Dali::Application::GetOrientation()
*/
Orientation();
/**
- * Virtual Destructor
+ * @brief Virtual Destructor
*/
virtual ~Orientation();
/**
- * Returns the orientation of the device in degrees.
+ * @brief Returns the orientation of the device in degrees.
+ *
* This is one of four discrete values, in degrees clockwise: 0, 90, 180, & 270
* For a device with a portrait form-factor:
* 0 indicates that the device is in the "normal" portrait orientation.
int GetDegrees() const;
/**
- * Returns the orientation of the device in radians.
+ * @brief Returns the orientation of the device in radians.
+ *
* This is one of four discrete values, in radians clockwise: 0, PI/2, PI, & 3xPI/2
* For a device with a portrait form-factor:
* 0 indicates that the device is in the "normal" portrait orientation.
float GetRadians() const;
/**
- * The user should connect to this signal so that they can be notified whenever
+ * @brief The user should connect to this signal so that they can be notified whenever
* the orientation of the device changes.
+ *
* @return The orientation change signal.
*/
OrientationSignalV2& ChangedSignal();
public: // Not intended for application developers
/**
- * This constructor is used by Dali::Application::GetOrientation().
+ * @brief This constructor is used by Dali::Application::GetOrientation().
+ *
* @param[in] orientation A pointer to the orientation object
*/
explicit DALI_INTERNAL Orientation( Internal::Adaptor::Orientation* orientation );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
class PixmapImage;
+/**
+ * @brief Pointer to Dali::PixmapImage.
+ */
typedef IntrusivePtr<PixmapImage> PixmapImagePtr;
/**
- * Used for displaying native Pixmap images.
+ * @brief Used for displaying native Pixmap images.
+ *
* The native pixmap can be created internally or
* externally by X11 or ECORE-X11.
*
public:
/**
- * PixmapImage can use pixmaps created by X11 or ECORE X11
+ * @brief PixmapImage can use pixmaps created by X11 or ECORE X11.
*/
enum PixmapAPI
{
};
/**
- * When creating a pixmap the color depth has to be specified
+ * @brief When creating a pixmap the color depth has to be specified.
*/
enum ColorDepth
{
};
/**
- * Create a new PixmapImage.
+ * @brief Create a new PixmapImage.
+ *
* Depending on hardware the width and height may have to be a power of two.
* @param[in] width The width of the image.
* @param[in] height The height of the image.
static PixmapImagePtr New( unsigned int width, unsigned int height, ColorDepth depth, Adaptor& adaptor );
/**
- * Create a new PixmapImage from an existing pixmap.
+ * @brief Create a new PixmapImage from an existing pixmap.
+ *
* @param[in] pixmap must be a X11 pixmap or a Ecore_X_Pixmap
* @param[in] adaptor reference to dali adaptor
* @return A smart-pointer to a newly allocated image.
static PixmapImagePtr New( boost::any pixmap, Adaptor& adaptor );
/**
- * Retrieve the internal pixmap
+ * @brief Retrieve the internal pixmap
+ *
* @param api whether to return a pixmap that can be used with X11 or EFL
* @return pixmap boost any object containing a pixmap of the type specified PixmapAPI
*/
boost::any GetPixmap( PixmapAPI api );
/**
- * Retrieve the display used to create the pixmap.
+ * @brief Retrieve the display used to create the pixmap.
+ *
* If the pixmap was created outside of Dali, then this display
* is the one Dali uses internally.
* @return boost any object containing the display
boost::any GetDisplay();
/**
- * Get a copy of the pixels used by PixmapImage.
+ * @brief Get a copy of the pixels used by PixmapImage.
+ *
* This is only supported for 24 bit RGB and 32 bit RGBA internal formats
* (COLOR_DEPTH_24 and COLOR_DEPTH_32).
* @param[out] pixbuf a vector to store the pixels in
bool GetPixels( std::vector<unsigned char>& pixbuf, unsigned int& width, unsigned int& height, Pixel::Format& pixelFormat ) const;
/**
- * Convert the current pixel contents to either a JPEG or PNG format
+ * @brief Convert the current pixel contents to either a JPEG or PNG format
* and write that to the filesytem.
+ *
* @param[in] filename Identify the filesytem location at which to write the
* encoded image. The extension determines the encoding used.
* The two valid encoding are (".jpeg"|".jpg") and ".png".
private:
/**
- * Private constructor
+ * @brief Private constructor
* @param[in] width The width of the image.
* @param[in] height The height of the image.
* @param[in] depth color depth of the pixmap
PixmapImage(unsigned int width, unsigned int height, ColorDepth depth, Adaptor& adaptor, boost::any pixmap);
/**
- * A reference counted object may only be deleted by calling Unreference().
+ * @brief A reference counted object may only be deleted by calling Unreference().
+ *
* The implementation should destroy the NativeImage resources.
*/
virtual ~PixmapImage();
/**
- * Undefined assignment operator.
+ * @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);
private:
- Internal::Adaptor::PixmapImage* mImpl;
-
+ Internal::Adaptor::PixmapImage* mImpl; ///< Implementation pointer
};
} // namespace Dali
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
namespace Dali DALI_IMPORT_API
{
+/**
+ * @brief The position and size of the render surface.
+ */
typedef Dali::Rect<int> PositionSize;
/**
+ * @brief Interface for a render surface onto which Dali draws.
+ *
* Dali::Adaptor requires a render surface to draw on to. This is
* usually a window in the native windowing system, or some other
* mapped pixel buffer.
*
- * Dali::Application will automatically create a render surface using a window.
- *
* The implementation of the factory method below should choose an appropriate
* implementation of RenderSurface for the given platform
*/
{
public:
/**
- * enumeration of surface types
+ * @brief enumeration of surface types
*/
enum SurfaceType
{
};
/**
- * When application uses pixmap surface, it can select rendering mode
+ * @brief When application uses pixmap surface, it can select rendering mode.
+ *
* RENDER_SYNC : application should call RenderSync() after posting the offscreen to onscreen
* RENDER_#FPS : the maximum performance will be limited designated number of frame
*/
};
/**
- * Constructor
+ * @brief Constructor
+ *
* Application or Adaptor needs to create the appropriate concrete RenderSurface type.
* @see CreateDefaultSurface
*/
RenderSurface();
/**
- * Virtual Destructor
+ * @brief Virtual Destructor.
*/
virtual ~RenderSurface();
/**
- * @returns the surface type
+ * @brief returns the surface type.
+ * @return the surface type
*/
virtual SurfaceType GetType() = 0;
/**
- * Returns the window or pixmap surface
+ * @brief Returns the window or pixmap surface.
* @return surface
*/
virtual boost::any GetSurface() = 0;
/**
- * Returns the display
+ * @brief Returns the display.
* @return display
*/
virtual boost::any GetDisplay() = 0;
/**
- * Return the size and position of the surface
+ * @brief Return the size and position of the surface.
+ * @return The position and size
*/
virtual PositionSize GetPositionSize() const = 0;
/**
- * Set frame update rate for pixmap surface type
+ * @brief Set frame update rate for pixmap surface type
*/
virtual void SetRenderMode(RenderMode mode) = 0;
/**
- * Get current fps for pixmap surface type
+ * @brief Get current fps for pixmap surface type
+ * @return The render mode
*/
virtual RenderMode GetRenderMode() const = 0;
private:
/**
- * Undefined copy constructor and assignment operator. RenderSurface cannot be copied
+ * @brief Undefined copy constructor. RenderSurface cannot be copied
*/
RenderSurface( const RenderSurface& rhs );
+
+ /**
+ * @brief Undefined assignment operator. RenderSurface cannot be copied
+ */
RenderSurface& operator=( const RenderSurface& rhs );
};
/**
- * Default surface factory function.
+ * @brief Default surface factory function.
+ *
* A surface is created with the given type.
*
* @param [in] type the type of surface to create
* @param [in] positionSize the position and size of the surface to create
* @param [in] name optional name of surface passed in
+ * @return The render surface
*/
RenderSurface* CreateDefaultSurface( RenderSurface::SurfaceType type, PositionSize positionSize, const std::string& name = "" );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * Plays sound effects.
+ * @brief Plays sound effects.
*/
class SoundPlayer : public BaseHandle
{
public:
- typedef SignalV2< void (SoundPlayer&) > SoundPlayFinishedSignalV2;
+ typedef SignalV2< void (SoundPlayer&) > SoundPlayFinishedSignalV2; ///< Sound play finished signal
// Signal Names
- static const char* const SIGNAL_SOUND_PLAY_FINISHED;
+ static const char* const SIGNAL_SOUND_PLAY_FINISHED; ///< name "sound-play-finished"
public:
/**
- * Create an uninitialized handle.
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by calling SoundPlayer::Get().
*/
SoundPlayer();
/**
- * Create an initialized handle to the SoundPlayer.
+ * @brief Create an initialized handle to the SoundPlayer.
+ *
* @return A handle to a newly allocated Dali resource.
*/
static SoundPlayer Get();
/**
- * Destructor
+ * @brief Destructor.
*/
~SoundPlayer();
/**
- * Plays a sound file.
+ * @brief Plays a sound file.
+ *
* @pre The SoundPlayer needs to be initialized.
* @param[in] fileName Path to the sound file to play.
* @return a handle to the currently playing sound file which can be used to stop.
int PlaySound(const std::string fileName);
/**
- * Stops the currently playing sound.
+ * @brief Stops the currently playing sound.
+ *
* @pre The SoundPlayer needs to be initialized.
+ * @param[in] handle
*/
void Stop(int handle);
/**
- * This signal will be emitted after a given sound file is completely played.
+ * @brief This signal will be emitted after a given sound file is completely played.
+ *
* @pre The SoundPlayer needs to be initialized.
* @return The signal to connect to.
*/
public: // Not intended for application developers
/**
- * This constructor is used by SoundPlayer::Get().
+ * @brief This constructor is used by SoundPlayer::Get().
+ *
* @param[in] soundPlayer A pointer to the sound player.
*/
SoundPlayer( Internal::Adaptor::SoundPlayer* soundPlayer );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
{
/**
+ * @brief Used to describe what style information has changed.
+ *
* This structure is used when any style changes occur and contains information about what exactly
* has changed.
*/
// Construction
/**
- * Default Constructor.
+ * @brief Default Constructor.
*/
StyleChange()
: defaultFontChange(false),
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
+ * @brief Monitors the platform for style changes.
+ *
* This is a handle to the adaptor's style monitor which holds the platform's style information.
* It provides a signal when any aspect of the default style changes on the device.
* @see Adaptor::GetStyleMonitor
{
public: // Typedefs
- // StyleChange Signal
- typedef SignalV2< void (StyleMonitor, StyleChange) > StyleChangeSignalV2;
+ typedef SignalV2< void (StyleMonitor, StyleChange) > StyleChangeSignalV2; ///< StyleChange Signal type
public: // Creation & Destruction
/**
- * Create an uninitialized StyleMonitor handle; this can be set by
- * retrieving the style monitor from the Adaptor or the Application
- * classes. Calling member functions when uninitialized is not
- * allowed.
+ * @brief Create an uninitialized StyleMonitor handle.
+ *
+ * Tthis can be set by retrieving the style monitor from the Adaptor
+ * or the Application classes. Calling member functions when
+ * uninitialized is not allowed.
*/
StyleMonitor();
/**
- * Creates a copy of the handle. The copy will point to the same implementation as the original.
+ * @brief Creates a copy of the handle.
+ *
+ * The copy will point to the same implementation as the original.
* @param[in] monitor The Style Monitor to copy from.
*/
StyleMonitor(const StyleMonitor& monitor);
/**
- * Retrieve the initialized instance of the StyleMonitor.
+ * @brief Retrieve the initialized instance of the StyleMonitor.
* @return Handle to StyleMonitor.
*/
static StyleMonitor Get();
/**
- * Destructor.
+ * @brief Destructor.
*/
virtual ~StyleMonitor();
/**
- * Downcast an Object handle to StyleMonitor handle. If handle
- * points to a StyleMonitor object the downcast produces a valid
- * handle. If not the returned handle is left uninitialized.
+ * @brief Downcast an Object handle to StyleMonitor handle.
+ *
+ * If handle points to a StyleMonitor object the downcast produces a
+ * valid handle. If not the returned handle is left uninitialized.
+ *
* @param[in] handle to An object @return handle to a Timer object
* or an uninitialized handle
*/
public: // Style Information
/**
- * Retrieves the default font family.
+ * @brief Retrieves the default font family.
* @return The default font family.
*/
std::string GetDefaultFontFamily() const;
/**
- * Retrieves the default font size
+ * @brief Retrieves the default font size
* @return The default font size.
*/
float GetDefaultFontSize() const;
/**
- * Retrieves the user defined Theme.
+ * @brief Retrieves the user defined Theme.
* @return The user defined Theme.
*/
const std::string& GetTheme() const;
/**
- * Sets an user defined Theme.
+ * @brief Sets an user defined Theme.
+ * @param[in] themeFilePath Path of the user defined theme
*/
void SetTheme(const std::string& themeFilePath);
public: // Signals
/**
- * This signal is emitted whenever the style changes on the device.
+ * @brief This signal is emitted whenever the style changes on the device.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallbackName(StyleMonitor styleMonitor, StyleChange change);
public: // Operators
/**
- * Assignment operator.
+ * @brief Assignment operator.
+ *
* The handle points to the same implementation as the one being copied from.
* @param[in] monitor The Style Monitor to copy from.
+ * @return reference to this object
*/
StyleMonitor& operator=(const StyleMonitor& monitor);
public: // Not intended for application developers
/**
- * This constructor is used internally to create a handle from an object pointer.
+ * @brief This constructor is used internally to create a handle from an object pointer.
* @param [in] styleMonitor A pointer the internal style monitor.
*/
explicit DALI_INTERNAL StyleMonitor(Internal::Adaptor::StyleMonitor* styleMonitor);
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
+ * @brief Mechanism to issue simple periodic or one-shot events.
+ *
* Timer is provided for application developers to be able to issue
* simple periodic or one-shot events. Please note that timer
* callback functions should return as soon as possible, because they
{
public: // Signal typedefs
- typedef SignalV2< bool () > TimerSignalV2;
+ typedef SignalV2< bool () > TimerSignalV2; ///< Timer finished signal callback type
public: // API
/**
- * Constructor, creates an uninitialized timer.
+ * @brief Constructor, creates an uninitialized timer.
+ *
* Call New to fully construct a timer.
*/
Timer();
/**
- * Create an tick Timer that emits periodic signal
+ * @brief Create an tick Timer that emits periodic signal.
+ *
* @param[in] milliSec Interval in milliseconds.
+ * @return a new timer
*/
static Timer New( unsigned int milliSec );
/**
- * Copy constructor
+ * @brief Copy constructor.
+ *
* @param[in] timer The handle to copy. The copied handle will point at the same implementation
*/
Timer( const Timer& timer );
/**
- * Assignment operator
+ * @brief Assignment operator.
+ *
* @param[in] timer The handle to copy. This handle will point at the same implementation
* as the copied handle.
* @return Reference to this timer handle
Timer& operator=( const Timer& timer );
/**
- * Destructor.
+ * @brief Destructor.
*/
virtual ~Timer();
/**
- * Downcast an Object handle to Timer handle. If handle points to a Timer object the
- * downcast produces a valid handle. If not the returned handle is left uninitialized.
+ * @brief Downcast an Object handle to Timer handle.
+ *
+ * If handle points to a Timer object the downcast produces a valid
+ * handle. If not the returned handle is left uninitialized.
+ *
* @param[in] handle to An object
* @return handle to a Timer object or an uninitialized handle
*/
using BaseHandle::operator=;
/**
- * Start timer.
+ * @brief Start timer.
+ *
* In case a Timer is already running it's time is reset and timer is restarted.
*/
void Start();
/**
- * Stop timer.
+ * @brief Stop timer.
*/
void Stop();
/**
- * Sets a new interval on the timer and starts the timer.
+ * @brief Sets a new interval on the timer and starts the timer.
+ *
* Cancels the previous timer.
* @param milliSec Interval in milliseconds.
*/
void SetInterval( unsigned int milliSec );
/**
- * Get interval of timer.
+ * @brief Get the interval of timer.
* @returns Interval in milliseconds.
*/
unsigned int GetInterval() const;
/**
- * Tells whether timer is running.
+ * @brief Tells whether timer is running.
* @return Whether Timer is started or not.
*/
bool IsRunning() const;
public: // Signals
/**
- * Signal emitted after specified time interval.
+ * @brief Signal emitted after specified time interval.
+ *
* The return of the callback decides whether signal emission stops or continues.
* If the callback function returns false emission will stop, if true it will continue
* This return value is ignored for one-shot events, which will always stop after the first execution.
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
}
/**
- * Text-to-speech Player
+ * @brief The Text-to-speech Player.
*/
class TtsPlayer : public BaseHandle
{
public: // ENUMs
/**
- * Enumerations of TTS mode
+ * @brief Enumeration of TTS mode.
*/
enum Mode
{
public: // API
/**
- * Create an uninitialized handle.
+ * @brief Create an uninitialized handle.
+ *
* This can be initialized by calling TtsPlayer::Get().
*/
TtsPlayer();
/**
- * Gets the singleton of the TtsPlayer for each mode.
+ * @brief Gets the singleton of the TtsPlayer for each mode.
+ *
* Internally, each tts player handles (singleton instance) are managed for each mode.
* @param mode the mode of tts-player
* @return A handle of the Ttsplayer for given mode.
static TtsPlayer Get(Dali::TtsPlayer::Mode mode = Dali::TtsPlayer::DEFAULT);
/**
- * Destructor
+ * @brief Destructor.
*/
~TtsPlayer();
/**
- * Start playing the audio data synthesized from the specified text.
+ * @brief Start playing the audio data synthesized from the specified text.
+ *
* @pre The TtsPlayer needs to be initialized.
* @param[in] text to play.
*/
void Play(const std::string& text);
/**
- * Stops playing the utterance.
+ * @brief Stops playing the utterance.
* @pre The TtsPlayer needs to be initialized.
*/
void Stop();
/**
- * Pauses the currently playing utterance.
+ * @brief Pauses the currently playing utterance.
* @pre The TtsPlayer needs to be initialized.
*/
void Pause();
/**
- * Resumes the previously paused utterance.
+ * @brief Resumes the previously paused utterance.
* @pre The TtsPlayer needs to be initialized.
*/
void Resume();
public: // Not intended for application developers
/**
- * This constructor is used by TtsPlayer::Get().
+ * @brief This constructor is used by TtsPlayer::Get().
* @param[in] ttsPlayer A pointer to the TTS player.
*/
TtsPlayer( Internal::Adaptor::TtsPlayer* ttsPlayer );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
{
/**
- * This namespace is provided for application developers to be able to show and hide the on-screen
- * keyboard. Key events are sent to the actor in focus. Focus is set through the actor Public API.
+ * @brief This namespace is provided for application developers to be able to show and hide the on-screen keyboard.
+ *
+ * Key events are sent to the actor in focus. Focus is set through the actor Public API.
*/
namespace VirtualKeyboard
{
// Enumerations
+/**
+ * @brief The direction of text.
+ */
enum TextDirection
{
LeftToRight,
RightToLeft,
};
+/**
+ * @brief The meaning of the return key.
+ */
enum ReturnKeyType
{
DEFAULT,
// Functions
/**
- * Show the virtual keyboard.
+ * @brief Show the virtual keyboard.
*/
void Show();
/**
- * Hide the virtual keyboard.
+ * @brief Hide the virtual keyboard.
*/
void Hide();
/**
- * Returns whether the virtual keyboard is visible or not.
+ * @brief Returns whether the virtual keyboard is visible or not.
* @return true if visible, false otherwise.
*/
bool IsVisible();
/**
- * Set the specific return key into the virtual keyboard.
+ * @brief Set the specific return key into the virtual keyboard.
* @param[in] type the kind of return key types.
*/
void SetReturnKeyType( ReturnKeyType type );
/**
- * Retrieve the current return key type.
+ * @brief Retrieve the current return key type.
* @return the type of retun key.
*/
ReturnKeyType GetReturnKeyType();
/**
- * Enable/disable prediction (predictive text)
+ * @brief Enable/disable prediction (predictive text).
+ *
* By default prediction text is enabled.
* @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);
/**
- * Returns whether prediction is enabled in the virtual keyboard
+ * @brief Returns whether prediction is enabled in the virtual keyboard
* @return true if predictive text enabled, false otherwise.
*/
bool IsPredictionEnabled();
-/*
- * Provides size and position of keyboard, position is relative to whether keyboard is visible or not.
+/**
+ * @brief Provides size and position of keyboard.
+ *
+ * Position is relative to whether keyboard is visible or not.
* If keyboard is not visible then position will be off the screen.
* If keyboard is not being shown when this method is called the keyboard is partially setup (IMFContext) to get
* the values then taken down. So ideally GetSizeAndPosition() should be called after Show().
Dali::Rect<int> GetSizeAndPosition();
/**
- * Rotates the keyboards orientation to the given angle
- * @param angle the angle is degrees the keyboard should be at 0 would be portrait then 90, 180, 270
+ * @brief Rotates the keyboard orientation to the given angle.
+ *
+ * A value of 0 indicates the portrait orientation.
+ * Other valid values are 90, 180, 270.
+ * @param angle the angle is in degrees.
*/
void RotateTo(int angle);
/**
- * Returns text direction of the keyboard's current input language.
+ * @brief Returns text direction of the keyboard's current input language.
* @return The direction of the text.
*/
TextDirection GetTextDirection();
/**
- * Connect to this signal to be notified when the virtual keyboard is shown or hidden.
+ * @brief Connect to this signal to be notified when the virtual keyboard is shown or hidden.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallbackName(bool keyboardShown);
StatusSignalV2& StatusChangedSignal();
/**
- * Connect to this signal to be notified when the virtual keyboard is reszied.
+ * @brief Connect to this signal to be notified when the virtual keyboard is resized.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallbackName();
VoidSignalV2& ResizedSignal();
/**
- * Connect to this signal to be notified when the virtual keyboard's language is changed.
+ * @brief Connect to this signal to be notified when the virtual keyboard's language is changed.
+ *
* A callback of the following type may be connected:
* @code
* void YourCallbackName();
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
class Orientation;
/**
- * The window class is used internally for drawing. It has an orientation
+ * @brief The window class is used internally for drawing.
+ *
+ * It has an orientation
* and indicator properties.
*/
class Window : public BaseHandle
// Enumerations
+ /**
+ * @brief Orientation of the window.
+ */
enum WindowOrientation
{
PORTRAIT = 0,
LANDSCAPE_INVERSE = 270
};
+ /**
+ * @brief Opacity of the indicator.
+ */
enum IndicatorBgOpacity
{
OPAQUE = 100, // Fully opaque indicator Bg
// Methods
/**
- * Create an initialized handle to a new Window.
+ * @brief Create an initialized handle to a new Window.
* @param[in] windowPosition The position and size of the window
* @param[in] name The window title
* @param[in] isTransparent Whether window is transparent
+ * @return a new window
*/
static Window New(PositionSize windowPosition, std::string name, bool isTransparent = false);
/**
- * Create an uninitalized handle. This can be initialized using
- * Dali::Application::GetWindow() or Dali::Window::New()
+ * @brief Create an uninitalized handle.
+ *
+ * This can be initialized using Dali::Application::GetWindow() or
+ * Dali::Window::New()
*/
Window();
/**
- * Destructor
+ * @brief Destructor
*/
virtual ~Window();
using BaseHandle::operator=;
/**
- * This sets whether the indicator bar should be shown or not
+ * @brief This sets whether the indicator bar should be shown or not.
* @param[in] show - true if the indicator bar should be shown
*/
void ShowIndicator( bool show );
/**
- * This sets the opacity mode of indicator bar
+ * @brief This sets the opacity mode of indicator bar.
* @param[in] opacity - The opacity mode
*/
void SetIndicatorBgOpacity( IndicatorBgOpacity opacity );
/**
- * This sets the orientation of indicator bar. It does not
- * implicitly show the indicator if it is currently hidden.
+ * @brief This sets the orientation of indicator bar.
+ *
+ * It does not implicitly show the indicator if it is currently
+ * hidden.
* @param[in] orientation The orientation
*/
void RotateIndicator(WindowOrientation orientation);
/**
- * Set the window name and class string
+ * @brief Set the window name and class string.
+ * @param[in] name The name of the window
+ * @param[in] klass The class of the window
*/
void SetClass(std::string name, std::string klass);
/**
- * Raise window to top of window stack
+ * @brief Raise window to top of window stack.
*/
void Raise();
/**
- * Lower window to bottom of window stack
+ * @brief Lower window to bottom of window stack.
*/
void Lower();
/**
- * Activate window to top of window stack even it is iconified
+ * @brief Activate window to top of window stack even it is iconified.
*/
void Activate();
/**
- * Get the orientation class ( to allow signal connection )
+ * @brief Get the orientation class ( to allow signal connection ).
*/
Orientation GetOrientation();
/**
- * Add an orientation to the list of available orientations
+ * @brief Add an orientation to the list of available orientations.
*/
void AddAvailableOrientation( WindowOrientation orientation );
/**
- * Remove an orientation from the list of available orientations
+ * @brief Remove an orientation from the list of available orientations.
*/
void RemoveAvailableOrientation( WindowOrientation orientation );
/**
- * Set the orientations that this window can rotate to. By default, the window
- * does not change orientation.
+ * @brief Set the orientations that this window can rotate to.
+ *
+ * By default, the window does not change orientation.
* @param[in] orientations The list of orientations
*/
void SetAvailableOrientations( const std::vector<WindowOrientation>& orientations );
/**
- * Get the list of orientations this window can rotate to.
+ * @brief Get the list of orientations this window can rotate to.
* @return the list of orientations
*/
const std::vector<WindowOrientation>& GetAvailableOrientations();
/**
- * Set a preferred orientation.
+ * @brief Set a preferred orientation.
* @pre orientation is in the list of available orientations
* @param[in] orientation The preferred orientation
*/
void SetPreferredOrientation( WindowOrientation orientation );
/**
- * Get the preferred orientation
+ * @brief Get the preferred orientation.
* @return The preferred orientation if previously set, or none.
*/
WindowOrientation GetPreferredOrientation();
/**
- * Returns the Drag & drop detector which can be used to receive drag & drop events.
+ * @brief Returns the Drag & drop detector which can be used to receive drag & drop events.
* @return A handle to the DragAndDropDetector.
*/
DragAndDropDetector GetDragAndDropDetector() const;
public: // Not intended for application developers
/**
- * This constructor is used by Dali::Application::GetWindow().
+ * @brief This constructor is used by Dali::Application::GetWindow().
* @param[in] window A pointer to the window.
*/
explicit Window( Internal::Adaptor::Window* window );
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
extern "C"
{
struct _Evas_Object;
- typedef struct _Evas_Object Evas_Object;
+ typedef struct _Evas_Object Evas_Object; ///< Forward declaration of Evas_Object
}
}
/**
+ * @brief Application class used by EFL applications that wish to use Dali.
+ *
* An EvasPlugin class object should be created by EFL application
* that wishes to use Dali. It provides a means for initialising the
* resources required by the Dali::Core.
{
public:
- typedef SignalV2< void (EvasPlugin&) > EvasPluginSignalV2;
+ typedef SignalV2< void (EvasPlugin&) > EvasPluginSignalV2; ///< Generic evas plugin signal type
public:
/**
- * This is the constructor for SLP EFL applications
+ * @brief This is the constructor for SLP EFL applications
* @param[in] parent A parent of new evas object
* @param[in] isTransparent Whether the object is transparent or not
* @param[in] initialWidth The initial width of Dali view port
EvasPlugin(Evas_Object* parent, bool isTransparent = false, unsigned int initialWidth = 1, unsigned int initialHeight = 1);
/**
- * Virtual destructor
+ * @brief Virtual destructor.
*/
virtual ~EvasPlugin();
public:
/**
- * Run Evas Plugin
+ * @brief Run Evas Plugin.
*/
void Run();
/**
- * Pause Evas Plugin
+ * @brief Pause Evas Plugin.
*/
void Pause();
/**
- * Resume Evas Plugin
+ * @brief Resume Evas Plugin.
*/
void Resume();
/**
- * Stop Evas Plugin
+ * @brief Stop Evas Plugin.
*/
void Stop();
/**
- * This returns Evas_Object* which created internally.
+ * @brief This returns Evas_Object* which is created internally.
* @return Evas_Object* evas image object which is drawen by dali.
*/
Evas_Object* GetEvasImageObject();
/**
- * This returns Evas_Object* which created internally.
+ * @brief This returns Evas_Object* which is created internally.
+ *
* Application should append this access object to custom focus chain for accessibility
*
* e.g. elm_object_focus_custom_chain_append(layout, dali_access_object, NULL);
Evas_Object* GetElmAccessObject();
/**
- * This returns Evas_Object* which created internally.
+ * @brief This returns Evas_Object* which is created internally.
+ *
* If application want to handle the keyboard focus among the efl and dali view part,
* application should set this object to efl layout instead of the evas image object from GetEvasImageObject()
* @return Evas_Object* evas object which can handle the focus internally. It is contained the image object.
Evas_Object* GetElmFocusObject();
/**
- * This returns internal Adaptor instance.
+ * @brief This returns the internal Adaptor instance.
*
* @return Adaptor* adaptor instance.
*/
public: // Signals
/**
- * The user should connect to this signal to determine when they should initialise
- * their application
+ * @brief Signal to notify the client when the application is ready to be initialized.
+ * @return The signal
*/
EvasPluginSignalV2& InitSignal();
/**
+ * @brief Signal to notify client when Dali has rendered at least one frame.
+ *
* The user should connect to this signal to be notified when Dali has started rendering
* and atleast one frame has been rendered.
+ * @return The signal
*/
EvasPluginSignalV2& FirstRenderCompletedSignal();
/**
- * The user should connect to this signal to determine when they should terminate
- * their application
+ * @brief Signal to notify the user when the application is about to be terminated.
+ *
+ * @return The signal
*/
EvasPluginSignalV2& TerminateSignal();
/**
+ * @brief Signal to notify the client when the adaptor is about to be paused.
+ *
* The user should connect to this signal if they need to perform any special
* activities when the application is about to be paused.
+ * @return The signal
*/
EvasPluginSignalV2& PauseSignal();
/**
+ * @brief Signal to notify the client when the adpator has resumed.
+ *
* The user should connect to this signal if they need to perform any special
* activities when the application has resumed.
+ * @return The signal
*/
EvasPluginSignalV2& ResumeSignal();
/**
- * This signal is emitted when the evas object is resized.
+ * @brief Signal to notify the client when the evas object is resized.
+ * @return The signal
*/
EvasPluginSignalV2& ResizeSignal();
/**
- * This signal is emitted when the evas object get the keyboard focus.
+ * @brief Signal to notify the client when the evas object get the keyboard focus.
+ * @return The signal
*/
EvasPluginSignalV2& FocusedSignal();
/**
- * This signal is emitted when the evas object lost the keyboard focus.
+ * @brief Signal to notify the client when the evas object lost the keyboard focus.
+ * @return The signal
*/
EvasPluginSignalV2& UnFocusedSignal();
private:
- Internal::Adaptor::EvasPlugin *mImpl;
+ Internal::Adaptor::EvasPlugin *mImpl; ///< Pointer to Implementation
friend class Internal::Adaptor::EvasPlugin;
};
//
/**
- * @addtogroup CAPI_DALI_FRAMEWORK
+ * @addtogroup CAPI_DALI_ADAPTOR_MODULE
* @{
*/
} // namespace Internal
/**
- * An NativeBufferPlugin class object should be created by Tizen application
+ * @brief Used by Tizen applications that wish to capture Dali output in a buffer.
+ *
+ * A NativeBufferPlugin class object should be created by Tizen application
* that wish to use Dali, capturing it's output using the Native Buffer Provider API.
* It provides a means for initialising the resources required by the Dali::Core.
*
{
public:
- typedef SignalV2< void (NativeBufferPlugin&) > NativeBufferPluginSignalV2;
+ typedef SignalV2< void (NativeBufferPlugin&) > NativeBufferPluginSignalV2; ///< Generic native buffer signal type
public:
/**
- * This is the constructor for Tizen applications
+ * @brief This is the constructor for Tizen applications.
* @param[in] initialWidth The initial width of Dali view port
* @param[in] initialHeight The initial height of Dali view port
* @param[in] isTransparent Whether the surface will be transparent or not
NativeBufferPlugin( unsigned int initialWidth, unsigned int initialHeight, bool isTransparent = false, unsigned int maxBufferCount = 2, RenderSurface::RenderMode mode = RenderSurface::RENDER_60FPS, const DeviceLayout& baseLayout = DeviceLayout::DEFAULT_BASE_LAYOUT);
/**
- * Virtual destructor
+ * @brief Virtual destructor.
*/
virtual ~NativeBufferPlugin();
public:
/**
- * Run the NativeBufferPlugin
+ * @brief Run the NativeBufferPlugin.
*/
void Run();
/**
- * Pause the NativeBufferPlugin
+ * @brief Pause the NativeBufferPlugin.
*/
void Pause();
/**
- * Resume the NativeBufferPlugin
+ * @brief Resume the NativeBufferPlugin.
*/
void Resume();
/**
- * Stop the NativeBufferPlugin
+ * @brief Stop the NativeBufferPlugin.
*/
void Stop();
/**
- * Get the internal Adaptor instance.
+ * @brief Get the internal Adaptor instance.
* @return A pointer to the internal adaptor instance.
*/
Dali::Adaptor* GetAdaptor();
/**
- * Get the native buffer object which contain rendered result.
+ * @brief Get the native buffer object which contain rendered result.
+ *
* Application should return back the buffer object to plugin by using AddNativeBufferToInput().
* @return A pointer to the native buffer object.
* @note do not destroy the native-buffer returned from this plugin.
native_buffer* GetNativeBufferFromOutput();
/**
- * Add the native buffer object which was consumed in application.
+ * @brief Add the native buffer object which was consumed in application.
+ *
* The added buffer will be re-used with render target
* @param nativeBuffer A pointer to the native buffer object.
* @return True if the operation is successful
bool AddNativeBufferToInput(native_buffer* nativeBuffer);
/**
- * Get number of native buffers in pool
+ * @brief Get number of native buffers in pool.
* @return vector2 which has input buffer count and output buffer count
*/
Vector2 GetBufferCount();
/**
- * Change surface size
+ * @brief Change surface size.
+ *
* NOT YET SUPPORTED
* @param width The width of target size
* @param height The height of target size
public: // Signals
/**
- * The user should connect to this signal to determine when they should initialise
- * their application
+ * @brief Signal to notify the client when the application is ready to be initialized.
+ * @return The signal
*/
NativeBufferPluginSignalV2& InitSignal();
/**
- * The user should connect to this signal to determine when they should terminate
- * their application
+ * @brief Signal to notify the user when the application is about to be terminated.
+ * @return The signal
*/
NativeBufferPluginSignalV2& TerminateSignal();
/**
+ * @brief Signal to notify the client when the adaptor is about to be paused.
+ *
* The user should connect to this signal if they need to perform any special
* activities when the application is about to be paused.
+ * @return The signal
*/
NativeBufferPluginSignalV2& PauseSignal();
/**
+ * @brief Signal to notify the client when the adpator has resumed.
+ *
* The user should connect to this signal if they need to perform any special
* activities when the application has resumed.
+ * @return The signal
*/
NativeBufferPluginSignalV2& ResumeSignal();
/**
- * The user should connect to this signal to be notified when DALi has started rendering
- * and at least one frame has been rendered.
+ * @brief Signal to notify the client when Dali has rendered at least one frame.
+ *
+ * The user should connect to this signal to be notified when Dali has started rendering
+ * and atleast one frame has been rendered.
+ * @return The signal
*/
NativeBufferPluginSignalV2& FirstRenderCompletedSignal();
/**
- * The user should connect to this signal to be notified when DALi has rendered one frame
+ * @brief Signal to notify the client when Dali has rendered one frame
+ * @return The signal
*/
NativeBufferPluginSignalV2& RenderSignal();
private:
- Internal::Adaptor::NativeBufferPlugin *mImpl;
+ Internal::Adaptor::NativeBufferPlugin *mImpl; ///< Pointer to implementation
friend class Internal::Adaptor::NativeBufferPlugin;
}; // class NativeBufferPlugin
projects / platform / core / uifw / dali-adaptor.git / commitdiff