virtual ~Window() = default;
static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent);
FocusChangeSignalType mFocusChangeSignal;
+ ResizeSignalType mResizeSignal;
+ int mRotationAngle;
DevelWindow::VisibilityChangedSignalType mVisibilityChangedSignal;
};
Window::Window( const PositionSize& positionSize )
: SceneHolder( positionSize ),
mFocusChangeSignal(),
+ mResizeSignal(),
+ mRotationAngle(90), // dummy angle for test coverage
mVisibilityChangedSignal()
{
}
return GetImplementation( *this ).mFocusChangeSignal;
}
+ResizeSignalType& Window::ResizeSignal()
+{
+ return GetImplementation( *this ).mResizeSignal;
+}
+
Window::KeyEventSignalType& Window::KeyEventSignal()
{
return GetImplementation( *this ).KeyEventSignal();
return Dali::Window( windowImpl );
}
+void SetPositionSize(Window window, PositionSize positionSize)
+{
+ Uint16Pair newSize(positionSize.width, positionSize.height);
+ GetImplementation( window ).mResizeSignal.Emit(window,newSize);
+}
+
+int GetPhysicalOrientation(Window window)
+{
+ return GetImplementation( window ).mRotationAngle;
+}
+
void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId )
{
CallbackBase::Execute( *callback, frameId );
class Window;
typedef Signal< void (Window,bool) > FocusChangeSignalType;
+typedef Signal< void (Window,Uint16Pair) > ResizeSignalType;
class Window : public BaseHandle
{
public:
+ using WindowSize = Uint16Pair;
+
using KeyEventSignalType = Signal< void (const KeyEvent&) >;
using TouchEventSignalType = Signal< void (const TouchEvent&) >;
+ using ResizeSignalType = Signal<void(Window, WindowSize)>;
static Window New(PositionSize windowPosition, const std::string& name, bool isTransparent = false);
static Window New(PositionSize windowPosition, const std::string& name, const std::string& className, bool isTransparent = false);
FocusChangeSignalType& FocusChangeSignal();
KeyEventSignalType& KeyEventSignal();
TouchEventSignalType& TouchedSignal();
+ ResizeSignalType& ResizeSignal();
public:
explicit Window( Internal::Adaptor::Window* window );
Dali::Window Get( Actor actor );
Dali::Window DownCast( BaseHandle handle );
+void SetPositionSize(Window window, PositionSize positionSize);
+int GetPhysicalOrientation(Window window);
void AddFrameRenderedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId );
void AddFramePresentedCallback( Window window, std::unique_ptr< CallbackBase > callback, int32_t frameId );
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/public-api/controls/video-view/video-view.h>
#include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
+#include <dali/devel-api/adaptor-framework/window-devel.h>
#include <dali/devel-api/adaptor-framework/video-sync-mode.h>
using namespace Dali;
END_TEST;
}
+
+// For coverage.
+int UtcDaliVideoViewSynchronizationForWindowRotation(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline("UtcDaliVideoViewSynchronizationForWindowRotation");
+
+ Window window = Window::New(PositionSize(0,0,100,100) ,"", false);
+ DALI_TEST_CHECK( window );
+
+ VideoView view = VideoView::New( true );
+ DALI_TEST_CHECK( view );
+
+ window.Add( view );
+
+ view.Play();
+
+ DevelWindow::SetPositionSize(window,PositionSize(0,0,480, 240));
+
+ application.SendNotification();
+ application.Render();
+
+ END_TEST;
+}
return;
}
+ Dali::Window window = DevelWindow::Get(self);
+ window.ResizeSignal().Connect(this, &VideoView::OnWindowResized);
+
int curPos = mVideoPlayer.GetPlayPosition();
if(mIsPlay)
SetFrameRenderCallback();
}
+void VideoView::OnWindowResized(Dali::Window winHandle, Dali::Window::WindowSize size)
+{
+ Dali::VideoPlayerPlugin::DisplayRotation videoAngle = mVideoPlayer.GetDisplayRotation();
+ int windowAngle = (DevelWindow::GetPhysicalOrientation(winHandle) / 90);
+
+ if(windowAngle != videoAngle)
+ {
+ mVideoPlayer.SetDisplayRotation(static_cast<Dali::VideoPlayerPlugin::DisplayRotation>(windowAngle));
+ }
+}
+
void VideoView::PlayAnimation(Dali::Animation animation)
{
if(mIsUnderlay && mSyncMode == Dali::VideoSyncMode::ENABLED)
#include <dali/devel-api/adaptor-framework/video-player.h>
#include <dali/devel-api/adaptor-framework/video-sync-mode.h>
#include <dali/integration-api/adaptor-framework/trigger-event-factory.h>
+#include <dali/public-api/adaptor-framework/window.h>
#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/object/property-conditions.h>
#include <dali/public-api/object/property-map.h>
*/
void OnAnimationFinished(Dali::Animation& animation);
+ /*
+ * @brief window's resize callback function
+ * This function is called when window is resized.
+ *
+ * @param[in] winHandle The resized window's handle.
+ * @param[in] size The window's new size.
+ */
+ void OnWindowResized(Dali::Window winHandle, Dali::Window::WindowSize size);
+
private:
Dali::VideoPlayer mVideoPlayer;
Dali::ImageDimensions mVideoSize;