#define DALI_SCENE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
*/
+// EXTERNAL INCLUDES
+#include <memory>
+
// INTERNAL INCLUDES
#include <dali/public-api/object/handle.h>
#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/common/vector-wrapper.h>
namespace Dali
{
class Actor;
-struct KeyEvent;
+class KeyEvent;
class Layer;
class RenderTaskList;
-class TouchData;
-struct WheelEvent;
+class TouchEvent;
+class WheelEvent;
namespace Internal DALI_INTERNAL
{
namespace Integration
{
-class RenderSurface;
struct Event;
/**
public:
typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
typedef Signal< void (const Dali::KeyEvent&) > KeyEventSignalType; ///< Key event signal type
- typedef Signal< void (const Dali::TouchData&) > TouchSignalType; ///< Touch signal type
- typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< Touched signal type
+ typedef Signal< bool (const Dali::KeyEvent&) > KeyEventGeneratedSignalType; ///< key event generated signal type
+ typedef Signal< void (const Dali::TouchEvent&) > TouchEventSignalType; ///< Touch signal type
+ typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< WheelEvent signal type
+
+ using FrameCallbackContainer = std::vector< std::pair< std::unique_ptr< CallbackBase >, int32_t > >;
/**
* @brief Create an initialized Scene handle.
*
- * @param[in] size The size of the scene in pixels as a Vector
+ * @param[in] size The size of the set surface for this scene
*
* @return a handle to a newly allocated Dali resource.
*/
- static Scene New( const Size& size );
+ static Scene New( Size size );
/**
* @brief Downcast an Object handle to Scene handle.
* @pre The actor has been initialized.
* @pre The actor does not have a parent.
*/
- void Add(Actor& actor);
+ void Add(Actor actor);
/**
* @brief Removes a child Actor from the Scene.
* @param[in] actor The child
* @pre The actor has been added to the stage.
*/
- void Remove(Actor& actor);
+ void Remove(Actor actor);
/**
* @brief Returns the size of the Scene in pixels as a Vector.
Vector2 GetDpi() const;
/**
+ * @brief Sets the background color.
+ *
+ * @param[in] color The new background color
+ */
+ void SetBackgroundColor( const Vector4& color );
+
+ /**
+ * @brief Gets the background color of the render　surface.
+ *
+ * @return The background color
+ */
+ Vector4 GetBackgroundColor() const;
+
+ /**
* @brief Retrieves the list of render-tasks.
*
* @return A valid handle to a RenderTaskList
Layer GetLayer( uint32_t depth ) const;
/**
- * @brief Binds the rendering surface to the scene
+ * @brief Informs the scene that the set surface has been resized.
*
- * @return The root layer
+ * @param[in] width The new width of the set surface
+ * @param[in] height The new height of the set surface
*/
- void SetSurface( Integration::RenderSurface& surface );
+ void SurfaceResized( float width, float height );
/**
- * @brief Gets the rendering surface bound to the scene
- *
- * @return The render surface
+ * @brief Informs the scene that the surface has been replaced.
*/
- Integration::RenderSurface* GetSurface() const;
+ void SurfaceReplaced();
+
+ /**
+ * @brief Discards this Scene from the Core.
+ */
+ void Discard();
+
+ /**
+ * @brief Retrieve the Scene that the given actor belongs to.
+ * @return The Scene.
+ */
+ static Integration::Scene Get( Actor actor );
/**
* This function is called when an event is queued.
void ProcessEvents();
/**
+ * @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
+ *
+ * @param[in] callback The function to call
+ * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+ *
+ * @note A callback of the following type may be used:
+ * @code
+ * void MyFunction( int frameId );
+ * @endcode
+ * This callback will be deleted once it is called.
+ *
+ * @note Ownership of the callback is passed onto this class.
+ */
+ void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+ /**
+ * @brief Adds a callback that is called when the frame is displayed on the display.
+ *
+ * @param[in] callback The function to call
+ * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
+ *
+ * @note A callback of the following type may be used:
+ * @code
+ * void MyFunction( int frameId );
+ * @endcode
+ * This callback will be deleted once it is called.
+ *
+ * @note Ownership of the callback is passed onto this class.
+ */
+ void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+
+ /**
+ * @brief Gets the callback list that is called when the frame rendering is done by the graphics driver.
+ *
+ * @param[out] callbacks The callback list
+ *
+ * @note This is called in the update thread.
+ */
+ void GetFrameRenderedCallback( FrameCallbackContainer& callbacks );
+
+ /**
+ * @brief Gets the callback list that is called when the frame is displayed on the display.
+ *
+ * @param[out] callbacks The callback list
+ *
+ * @note This is called in the update thread.
+ */
+ void GetFramePresentedCallback( FrameCallbackContainer& callbacks );
+
+ /**
* @brief This signal is emitted just after the event processing is finished.
*
* @return The signal to connect to
KeyEventSignalType& KeyEventSignal();
/**
+ * @brief The user would connect to this signal to get a KeyEvent when KeyEvent is generated.
+ *
+ * If the control already consumed key event, KeyEventProcessor do not need to Emit keyEvent.
+ * Therefore, KeyinputManager first checks whether KeyEvent is generated as KeyEventGeneratedSignal.
+ * After that keyEventProcessor must invoke KeyEvent only if KeyEventGeneratedSignal () is not consumed.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * bool YourCallbackName(const KeyEvent& event);
+ * @endcode
+ *
+ * @return The return is true if KeyEvent is consumed, otherwise false.
+ */
+ KeyEventGeneratedSignalType& KeyEventGeneratedSignal();
+
+ /**
* @brief This signal is emitted when the screen is touched and when the touch ends
* (i.e. the down & up touch events only).
*
* An interrupted event will also be emitted (if it occurs).
* A callback of the following type may be connected:
* @code
- * void YourCallbackName( TouchData event );
+ * void YourCallbackName( TouchEvent event );
* @endcode
*
* @return The touch signal to connect to
* @note Motion events are not emitted.
*/
- TouchSignalType& TouchSignal();
+ TouchEventSignalType& TouchedSignal();
/**
* @brief This signal is emitted when wheel event is received.
projects / platform / core / uifw / dali-core.git / blobdiff