uint32_t verticalDpi,
ResourcePolicy::DataRetention policy,
bool initialize )
-: mCore( NULL ),
+: mRenderSurface( NULL ),
+ mCore( NULL ),
mSurfaceWidth( surfaceWidth ),
mSurfaceHeight( surfaceHeight ),
mFrame( 0u ),
/**
* @brief Returns the file stream
* @return FILE.
+ * @note This class is responsible for closing the file so the caller SHOULD NOT call fclose() on the returned pointer.
*/
FILE* GetFile();
return GetImplementation( window ).KeyEventSignal();
}
-KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Window window )
-{
- return GetImplementation( window ).KeyEventGeneratedSignal();
-}
-
TouchSignalType& TouchSignal( Window window )
{
return GetImplementation( window ).TouchSignal();
return GetImplementation( window ).GetParent();
}
+Window DownCast( BaseHandle handle )
+{
+ return Window( dynamic_cast<Dali::Internal::Adaptor::Window*>( handle.GetObjectPtr()) );
+}
} // namespace DevelWindow
} // namespace Dali
typedef Signal< void (const KeyEvent&) > KeyEventSignalType; ///< Key event signal type
-typedef Signal< bool (const KeyEvent&) > KeyEventGeneratedSignalType; ///< Key event generated signal type
-
typedef Signal< void (const TouchData&) > TouchSignalType; ///< Touch signal type
typedef Signal< void (const WheelEvent&) > WheelEventSignalType; ///< Touched signal type
DALI_ADAPTOR_API KeyEventSignalType& KeyEventSignal( Window window );
/**
- * @brief This signal is emitted when key event is received.
- *
- * A callback of the following type may be connected:
- * @code
- * bool YourCallbackName(const KeyEvent& event);
- * @endcode
- * @param[in] window The window instance
- * @return The signal to connect to
- */
-DALI_ADAPTOR_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Window window );
-
-/**
* @brief This signal is emitted when the screen is touched and when the touch ends
* (i.e. the down & up touch events only).
*
*/
DALI_ADAPTOR_API Window GetParent( Window window );
+/**
+ * @brief Downcast sceneHolder to window
+ *
+ * @param[in] handle The handle need to downcast
+ * @return The window cast from SceneHolder
+ */
+DALI_ADAPTOR_API Window DownCast( BaseHandle handle );
+
} // namespace DevelWindow
} // namespace Dali
class SceneHolder;
}
+using SceneHolderList = std::vector<Dali::Integration::SceneHolder>;
+
namespace Internal
{
public:
typedef Signal< void (Adaptor&) > AdaptorSignalType; ///< Generic Type for adaptor signals
- typedef Signal< void (Window&) > WindowCreatedSignalType; ///< Window created signal type
+ typedef Signal< void (Dali::Integration::SceneHolder&) > WindowCreatedSignalType; ///< SceneHolder created signal type
using SurfaceSize = Uint16Pair; ///< Surface size type
Dali::WindowContainer GetWindows() const;
/**
+ * @brief Get the list of scene holders.
+ * @return The list of scene holers
+ */
+ SceneHolderList GetSceneHolders() const;
+
+ /**
* @brief Called when the window becomes fully or partially visible.
*/
void OnWindowShown();
AdaptorSignalType& LanguageChangedSignal();
/**
- * @brief This signal is emitted when a new window is created
+ * @brief This signal is emitted when a new window (scene holder) is created
*
* @return The signal to connect to
*/
*/
static Dali::Integration::SceneHolder Get( Dali::Actor actor );
+ /**
+ * @copydoc Dali::Integration::SceneHolder::KeyEventSignal()
+ */
+ Dali::Integration::SceneHolder::KeyEventSignalType& KeyEventSignal() { return mScene.KeyEventSignal(); }
+
+ /**
+ * @copydoc Dali::Integration::SceneHolder::KeyEventGeneratedSignal()
+ */
+ Dali::Integration::SceneHolder::KeyEventGeneratedSignalType& KeyEventGeneratedSignal() { return mScene.KeyEventGeneratedSignal(); }
+
+ /**
+ * @copydoc Dali::Integration::SceneHolder::TouchSignal()
+ */
+ Dali::Integration::SceneHolder::TouchSignalType& TouchSignal() { return mScene.TouchSignal(); }
+
+ /**
+ * @copydoc Dali::Integration::SceneHolder::WheelEventSignal()
+ */
+ Dali::Integration::SceneHolder::WheelEventSignalType& WheelEventSignal() { return mScene.WheelEventSignal(); }
+
public: // The following methods can be overridden if required
/**
return Internal::Adaptor::SceneHolder::Get( actor );
}
+SceneHolder::KeyEventSignalType& SceneHolder::KeyEventSignal()
+{
+ return GetImplementation(*this).KeyEventSignal();
+}
+
+SceneHolder::KeyEventGeneratedSignalType& SceneHolder::KeyEventGeneratedSignal()
+{
+ return GetImplementation(*this).KeyEventGeneratedSignal();
+}
+
+SceneHolder::TouchSignalType& SceneHolder::TouchSignal()
+{
+ return GetImplementation(*this).TouchSignal();
+}
+
+SceneHolder::WheelEventSignalType& SceneHolder::WheelEventSignal()
+{
+ return GetImplementation(*this).WheelEventSignal();
+}
+
}// Integration
} // Dali
#include <dali/public-api/dali-adaptor-common.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/math/vector4.h>
+#include <dali/public-api/signals/dali-signal.h>
namespace Dali
{
class Actor;
class Layer;
class Any;
+class TouchData;
struct TouchPoint;
struct WheelEvent;
struct KeyEvent;
{
public:
+ typedef Signal< void (const Dali::KeyEvent&) > KeyEventSignalType; ///< Key event signal type
+
+ typedef Signal< bool (const Dali::KeyEvent&) > KeyEventGeneratedSignalType; ///< Key event generated signal type
+
+ typedef Signal< void (const Dali::TouchData&) > TouchSignalType; ///< Touch signal type
+
+ typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< Touched signal type
+
/**
* @brief Create an uninitialized SceneHolder handle.
*/
*/
static SceneHolder Get( Actor actor );
+ /**
+ * @brief This signal is emitted when key event is received.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName(const KeyEvent& event);
+ * @endcode
+ * @return The signal to connect to
+ */
+ KeyEventSignalType& KeyEventSignal();
+
+ /**
+ * @brief This signal is emitted when key event is received.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * bool YourCallbackName(const KeyEvent& event);
+ * @endcode
+ * @return The signal to connect to
+ */
+ 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).
+ *
+ * If there are multiple touch points, then this will be emitted when the first touch occurs and
+ * then when the last finger is lifted.
+ * An interrupted event will also be emitted (if it occurs).
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName( TouchData event );
+ * @endcode
+ * @return The touch signal to connect to
+ * @note Motion events are not emitted.
+ */
+ TouchSignalType& TouchSignal();
+
+ /**
+ * @brief This signal is emitted when wheel event is received.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName(const WheelEvent& event);
+ * @endcode
+ * @return The signal to connect to
+ */
+ WheelEventSignalType& WheelEventSignal();
+
public: // Not intended for application developers
/**
defaultWindow->SetAdaptor( Get() );
- Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( defaultWindow ) );
- if ( window )
- {
- mWindowCreatedSignal.Emit( window );
- }
+ Dali::Integration::SceneHolder defaultSceneHolder( defaultWindow );
+
+ mWindowCreatedSignal.Emit( defaultSceneHolder );
const unsigned int timeInterval = mEnvironmentOptions->GetObjectProfilerInterval();
if( 0u < timeInterval )
}
std::string systemCachePath = GetSystemCachePath();
- if ( systemCachePath.c_str() != NULL )
+ if ( ! systemCachePath.empty() )
{
Dali::FileStream fileStream( systemCachePath + "gpu-environment.conf", Dali::FileStream::READ | Dali::FileStream::TEXT );
std::fstream& stream = dynamic_cast<std::fstream&>( fileStream.GetStream() );
// Add the new Window to the container - the order is not important
mWindows.push_back( &windowImpl );
- Dali::Window window( dynamic_cast<Dali::Internal::Adaptor::Window*>( &windowImpl ) );
- if ( window )
- {
- mWindowCreatedSignal.Emit( window );
- }
+ mWindowCreatedSignal.Emit( childWindow );
return true;
}
return windows;
}
+Dali::SceneHolderList Adaptor::GetSceneHolders() const
+{
+ Dali::SceneHolderList sceneHolderList;
+
+ for( auto iter = mWindows.begin(); iter != mWindows.end(); ++iter )
+ {
+ sceneHolderList.push_back( Dali::Integration::SceneHolder( *iter ) );
+ }
+
+ return sceneHolderList;
+}
+
Adaptor::Adaptor(Dali::Integration::SceneHolder window, Dali::Adaptor& adaptor, Dali::RenderSurfaceInterface* surface, EnvironmentOptions* environmentOptions)
: mResizedSignal(),
mLanguageChangedSignal(),
*/
Dali::WindowContainer GetWindows() const;
+ /**
+ * @copydoc Dali::Adaptor::GetSceneHolders()
+ */
+ Dali::SceneHolderList GetSceneHolders() const;
+
public:
/**
AdaptorSignalType mResizedSignal; ///< Resized signal.
AdaptorSignalType mLanguageChangedSignal; ///< Language changed signal.
- WindowCreatedSignalType mWindowCreatedSignal; ///< Window created signal.
+ WindowCreatedSignalType mWindowCreatedSignal; ///< Window created signal.
Dali::Adaptor& mAdaptor; ///< Reference to public adaptor instance.
State mState; ///< Current state of the adaptor
return mImpl->GetWindows();
}
+SceneHolderList Adaptor::GetSceneHolders() const
+{
+ return mImpl->GetSceneHolders();
+}
+
void Adaptor::OnWindowShown()
{
mImpl->OnWindowShown();
{
mRunning = true;
- elm_init(*mArgc, *mArgv);
+ elm_init( mArgc ? *mArgc : 0, mArgv ? *mArgv : nullptr );
Impl::AppCreate(this);
if( callbackData.update )
{
+ if( cursorPosition )
+ {
+ mIMFCursorPosition = static_cast<int>( callbackData.cursorPosition );
+ *cursorPosition = mIMFCursorPosition;
+ }
+
if( text )
{
const char* plainText = callbackData.currentText.c_str();
+
if( plainText )
{
+ // The memory allocated by strdup() can be freed by ecore_imf_context_surrounding_get() internally.
+ *text = strdup( plainText );
+
// If the current input panel is password mode, dali should replace the plain text with '*' (Asterisk) character.
if( ecore_imf_context_input_hint_get( mIMFContext ) & ECORE_IMF_INPUT_HINT_SENSITIVE_DATA )
{
- char* iter = NULL;
- for( iter = const_cast<char*>( plainText ); iter && *iter; ++iter )
+ for( char* iter = *text; *iter; ++iter )
{
*iter = '*';
}
}
- }
- // The memory allocated by strdup() can be freed by ecore_imf_context_surrounding_get() internally.
- *text = strdup( plainText );
- }
- if( cursorPosition )
- {
- mIMFCursorPosition = static_cast<int>( callbackData.cursorPosition );
- *cursorPosition = mIMFCursorPosition;
+ return EINA_TRUE;
+ }
}
}
- return EINA_TRUE;
+ return EINA_FALSE;
}
/**
mWindowHeight( 0 ),
mFocusChangedSignal(),
mResizedSignal(),
- mDeleteRequestSignal()
+ mDeleteRequestSignal(),
+ mFocusChangeSignal(),
+ mResizeSignal()
{
}
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
mAdaptor->SurfaceResizePrepare( mSurface.get(), newSize );
+ Dali::Window handle( this );
mResizedSignal.Emit( newSize );
-
+ mResizeSignal.Emit( handle, newSize );
mAdaptor->SurfaceResizeComplete( mSurface.get(), newSize );
}
}
void Window::OnFocusChanged( bool focusIn )
{
+ Dali::Window handle( this );
mFocusChangedSignal.Emit( focusIn );
+ mFocusChangeSignal.Emit( handle, focusIn );
}
void Window::OnOutputTransformed()
mAdaptor->SurfaceResizePrepare( mSurface.get(), Adaptor::SurfaceSize( mRotationAngle, mWindowHeight ) );
// Emit signal
+ Dali::Window handle( this );
mResizedSignal.Emit( Dali::Window::WindowSize( mRotationAngle, mWindowHeight ) );
+ mResizeSignal.Emit( handle, Dali::Window::WindowSize( mRotationAngle, mWindowHeight ) );
mAdaptor->SurfaceResizeComplete( mSurface.get(), Adaptor::SurfaceSize( mRotationAngle, mWindowHeight ) );
}
typedef Dali::Window::IndicatorSignalType IndicatorSignalType;
typedef Dali::Window::FocusSignalType FocusSignalType;
typedef Dali::Window::ResizedSignalType ResizedSignalType;
+ typedef Dali::Window::FocusChangeSignalType FocusChangeSignalType;
+ typedef Dali::Window::ResizeSignalType ResizeSignalType;
typedef Signal< void () > SignalType;
/**
FocusSignalType& FocusChangedSignal() { return mFocusChangedSignal; }
/**
+ * @copydoc Dali::Window::WindowFocusChangedSignal()
+ */
+ FocusChangeSignalType& FocusChangeSignal() { return mFocusChangeSignal; }
+ /**
* @copydoc Dali::Window::ResizedSignal()
*/
ResizedSignalType& ResizedSignal() { return mResizedSignal; }
+ /**
+ * @copydoc Dali::Window::ResizedSignal()
+ */
+ ResizeSignalType& ResizeSignal() { return mResizeSignal; }
/**
* This signal is emitted when the window is requesting to be deleted
*/
Dali::DevelWindow::EventProcessingFinishedSignalType& EventProcessingFinishedSignal() { return mScene.EventProcessingFinishedSignal(); }
- /**
- * @copydoc Dali::Window::KeyEventSignal()
- */
- Dali::DevelWindow::KeyEventSignalType& KeyEventSignal() { return mScene.KeyEventSignal(); }
-
- /**
- * @copydoc Dali::Window::KeyEventGeneratedSignal()
- */
- Dali::DevelWindow::KeyEventGeneratedSignalType& KeyEventGeneratedSignal() { return mScene.KeyEventGeneratedSignal(); }
-
- /**
- * @copydoc Dali::Window::TouchSignal()
- */
- Dali::DevelWindow::TouchSignalType& TouchSignal() { return mScene.TouchSignal(); }
-
- /**
- * @copydoc Dali::Window::WheelEventSignal()
- */
- Dali::DevelWindow::WheelEventSignalType& WheelEventSignal() { return mScene.WheelEventSignal(); }
-
private:
WindowRenderSurface* mWindowSurface; ///< The window rendering surface
FocusSignalType mFocusChangedSignal;
ResizedSignalType mResizedSignal;
SignalType mDeleteRequestSignal;
-
-
+ FocusChangeSignalType mFocusChangeSignal;
+ ResizeSignalType mResizeSignal;
};
} // namespace Adaptor
Window::FocusSignalType& Window::FocusChangedSignal()
{
+ DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: FocusChangedSignal is deprecated and will be removed from next release.\n" );
return GetImplementation(*this).FocusChangedSignal();
}
+Window::FocusChangeSignalType& Window::FocusChangeSignal()
+{
+ return GetImplementation(*this).FocusChangeSignal();
+}
+
void Window::SetAcceptFocus( bool accept )
{
GetImplementation(*this).SetAcceptFocus( accept );
Window::ResizedSignalType& Window::ResizedSignal()
{
+ DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: ResizedSignal is deprecated and will be removed from next release.\n" );
return GetImplementation(*this).ResizedSignal();
}
+Window::ResizeSignalType& Window::ResizeSignal()
+{
+ return GetImplementation(*this).ResizeSignal();
+}
+
void Window::SetSize( Window::WindowSize size )
{
GetImplementation(*this).SetSize( size );
typedef Uint16Pair WindowPosition; ///< Window position type @SINCE_1_2.60
typedef Signal< void (bool) > IndicatorSignalType; ///< @DEPRECATED_1_4.9 @brief Indicator state signal type @SINCE_1_0.0
- typedef Signal< void (bool) > FocusSignalType; ///< Window focus signal type @SINCE_1_2.60
- typedef Signal< void (WindowSize) > ResizedSignalType; ///< Window resized signal type @SINCE_1_2.60
-
+ typedef Signal< void (bool) > FocusSignalType; ///< @DEPRECATED_1_4.35 @brief Window focus signal type @SINCE_1_2.60
+ typedef Signal< void (WindowSize) > ResizedSignalType; ///< @DEPRECATED_1_4.35 @brief Window resized signal type @SINCE_1_2.60
+ typedef Signal< void (Window,bool) > FocusChangeSignalType; ///< Window focus signal type @SINCE_1_4.35
+ typedef Signal< void (Window,WindowSize) > ResizeSignalType; ///< Window resized signal type @SINCE_1_4.35
public:
// Enumerations
IndicatorSignalType& IndicatorVisibilityChangedSignal() DALI_DEPRECATED_API;
/**
+ * @DEPRECATED_1_4.35
* @brief The user should connect to this signal to get a timing when window gains focus or loses focus.
*
* A callback of the following type may be connected:
* @SINCE_1_2.60
* @return The signal to connect to
*/
- FocusSignalType& FocusChangedSignal();
+ FocusSignalType& FocusChangedSignal() DALI_DEPRECATED_API;
/**
* @brief This signal is emitted when the window is resized.
* @SINCE_1_2.60
* @return The signal to connect to
*/
- ResizedSignalType& ResizedSignal();
+ ResizedSignalType& ResizedSignal() DALI_DEPRECATED_API;
+
+ /**
+ * @brief The user should connect to this signal to get a timing when window gains focus or loses focus.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName( Window window, bool focusIn );
+ * @endcode
+ * The parameter is true if window gains focus, otherwise false.
+ * and window means this signal was called from what window
+ *
+ * @SINCE_1_4.35
+ * @return The signal to connect to
+ */
+ FocusChangeSignalType& FocusChangeSignal();
+
+ /**
+ * @brief This signal is emitted when the window is resized.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName( Window window, int width, int height );
+ * @endcode
+ * The parameters are the resized width and height.
+ * and window means this signal was called from what window
+ *
+ * @SINCE_1_4.35
+ * @return The signal to connect to
+ */
+ ResizeSignalType& ResizeSignal();
public: // Not intended for application developers
/// @cond internal
const unsigned int ADAPTOR_MAJOR_VERSION = 1;
const unsigned int ADAPTOR_MINOR_VERSION = 4;
-const unsigned int ADAPTOR_MICRO_VERSION = 35;
+const unsigned int ADAPTOR_MICRO_VERSION = 36;
const char * const ADAPTOR_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali-adaptor
Summary: The DALi Tizen Adaptor
-Version: 1.4.35
+Version: 1.4.36
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-adaptor.git / commitdiff