{
case TextAbstraction::FontClient::GlyphBufferData::CompressionType::NO_COMPRESSION:
{
- bufferSize = outBufferData.width * outBufferData.height * Pixel::GetBytesPerPixel(outBufferData.format);
+ bufferSize = static_cast<size_t>(outBufferData.width) * static_cast<size_t>(outBufferData.height) * static_cast<size_t>(Pixel::GetBytesPerPixel(outBufferData.format));
compressedBuffer = (uint8_t*)malloc(bufferSize);
if(DALI_UNLIKELY(compressedBuffer == nullptr))
const bool considerPadding = (widthByte & 1) ? true : false;
// For BIT_PER_PIXEL_4 type, we can know final compressed buffer size immediatly.
- bufferSize = outBufferData.height * (componentCount + (considerPadding ? 1 : 0));
+ bufferSize = static_cast<size_t>(outBufferData.height) * static_cast<size_t>(componentCount + (considerPadding ? 1 : 0));
compressedBuffer = (uint8_t*)malloc(bufferSize);
if(DALI_UNLIKELY(compressedBuffer == nullptr))
{
mDisplayConnection(nullptr),
mScene(),
mFullSwapNextFrame(true),
- mIsResizing(false),
mDepthBufferRequired(Integration::DepthBufferAvailable::FALSE),
mStencilBufferRequired(Integration::StencilBufferAvailable::FALSE)
{
* @brief Return the orientation of the surface.
* @return The orientation
*/
- virtual int GetOrientation() const = 0;
+ virtual int GetSurfaceOrientation() const = 0;
+
+ /**
+ * @brief Return the orientation of the screen.
+ * @return The screen orientation
+ */
+ virtual int GetScreenOrientation() const = 0;
/**
* @brief InitializeGraphics the platform specific graphics surface interfaces
mFullSwapNextFrame = true;
}
- /**
- * @brief Sets whether this surface is being resized.
- */
- void SetIsResizing(bool isResizing)
- {
- mIsResizing = isResizing;
- }
-
private:
/**
* @brief Undefined copy constructor. RenderSurface cannot be copied
Dali::DisplayConnection* mDisplayConnection;
WeakHandle<Dali::Integration::Scene> mScene;
bool mFullSwapNextFrame; ///< Whether the full surface swap is required
- bool mIsResizing; ///< Whether the surface is being resized
private:
Integration::DepthBufferAvailable mDepthBufferRequired; ///< Whether the depth buffer is required
mScene.SurfaceReplaced();
- SurfaceResized();
+ PositionSize surfacePositionSize = surface->GetPositionSize();
+
+ SurfaceResized(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height));
InitializeDpi();
OnSurfaceSet(surface);
}
-void SceneHolder::SurfaceResized()
+void SceneHolder::SurfaceResized(float width, float height)
{
- PositionSize surfacePositionSize = mSurface->GetPositionSize();
- mScene.SurfaceResized(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height));
+ mScene.SurfaceResized(width, height);
mSurface->SetFullSwapNextFrame();
// Create the scene
PositionSize surfacePositionSize = mSurface->GetPositionSize();
- int orientation = mSurface->GetOrientation();
- mScene = Dali::Integration::Scene::New(Size(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height)), orientation);
+ int windowOrientation = mSurface->GetSurfaceOrientation();
+ int screenOrientation = mSurface->GetScreenOrientation();
+
+ mScene = Dali::Integration::Scene::New(Size(static_cast<float>(surfacePositionSize.width), static_cast<float>(surfacePositionSize.height)), windowOrientation, screenOrientation);
Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
mAdaptor = &adaptorImpl;
OnResume();
}
-void SceneHolder::SurfaceRotated(float width, float height, int orientation)
+void SceneHolder::SurfaceRotated(float width, float height, int32_t windowOrientation, int32_t screenOrientation)
{
- mScene.SurfaceRotated(width, height, orientation);
+ mScene.SurfaceRotated(width, height, windowOrientation, screenOrientation);
}
void SceneHolder::SetRotationCompletedAcknowledgement()
/**
* @brief Called when the surface set is resized.
+ * @param[in] width the resized window's width
+ * @param[in] height the resized window's height
*/
- void SurfaceResized();
+ void SurfaceResized(float width, float height);
/**
* @brief Get the render surface
*
* @param[in] width The width of rotated surface
* @param[in] height The height of rotated surface
- * @param[in] orientation The orientation of rotated surface
+ * @param[in] windowOrientation the current window orientation
+ * @param[in] screenOrientation the current screen orientation
*/
- void SurfaceRotated(float width, float height, int orientation);
+ void SurfaceRotated(float width, float height, int32_t windowOrientation, int32_t screenOrientation);
/**
* @brief Send message to acknowledge window rotation with current window orientation.
WindowContainer windows;
mAdaptorInterfaces.GetWindowContainerInterface(windows);
- bool sceneSurfaceResized;
-
for(auto&& window : windows)
{
Dali::Integration::Scene scene = window->GetScene();
{
Integration::RenderStatus windowRenderStatus;
- // Get Surface Resized flag
- sceneSurfaceResized = scene.IsSurfaceRectChanged();
- windowSurface->SetIsResizing(sceneSurfaceResized);
+ const bool sceneSurfaceResized = scene.IsSurfaceRectChanged();
// clear previous frame damaged render items rects, buffer history is tracked on surface level
mDamagedRects.clear();
if(!mImpl->mNativeDrawContext)
{
EGLint configId{0u};
- EGLint size{0u};
- eglGetConfigs(display, nullptr, 0, &size);
- std::vector<EGLConfig> configs;
- configs.resize(size);
- eglGetConfigs(display, configs.data(), configs.size(), &size);
+ eglQueryContext(display, mImpl->mController.GetSharedContext(), EGL_CONFIG_ID, &configId);
- eglQueryContext(display, context, EGL_CONFIG_ID, &configId);
+ EGLint configAttribs[3];
+ configAttribs[0] = EGL_CONFIG_ID;
+ configAttribs[1] = configId;
+ configAttribs[2] = EGL_NONE;
+
+ EGLConfig config;
+ EGLint numConfigs;
+ if(eglChooseConfig(display, configAttribs, &config, 1, &numConfigs) != EGL_TRUE)
+ {
+ DALI_LOG_ERROR("eglChooseConfig failed!\n");
+ return;
+ }
auto version = int(mImpl->mController.GetGLESVersion());
attribs.push_back(version % 10);
attribs.push_back(EGL_NONE);
- mImpl->mNativeDrawContext = eglCreateContext(display, configs[configId], mImpl->mController.GetSharedContext(), attribs.data());
+ mImpl->mNativeDrawContext = eglCreateContext(display, config, mImpl->mController.GetSharedContext(), attribs.data());
+ if(mImpl->mNativeDrawContext == EGL_NO_CONTEXT)
+ {
+ DALI_LOG_ERROR("eglCreateContext failed!\n");
+ return;
+ }
}
eglMakeCurrent(display, drawSurface, readSurface, mImpl->mNativeDrawContext);
}
// Copy embedded levels as fribidi_reorder_line() may change them.
- const uint32_t embeddedLevelsSize = numberOfCharacters * sizeof(FriBidiLevel);
- FriBidiLevel* embeddedLevels = reinterpret_cast<FriBidiLevel*>(malloc(embeddedLevelsSize));
+ const size_t embeddedLevelsSize = static_cast<std::size_t>(numberOfCharacters) * sizeof(FriBidiLevel);
+ FriBidiLevel* embeddedLevels = reinterpret_cast<FriBidiLevel*>(malloc(embeddedLevelsSize));
if(embeddedLevels)
{
memcpy(embeddedLevels, bidirectionalInfo->embeddedLevels + firstCharacterIndex, embeddedLevelsSize);
int fixedSizeIndex = 0;
for(; fixedSizeIndex < ftFace->num_fixed_sizes; ++fixedSizeIndex)
{
- const PointSize26Dot6 fixedSize = ftFace->available_sizes[fixedSizeIndex].size;
+ const PointSize26Dot6 fixedSize = static_cast<PointSize26Dot6>(ftFace->available_sizes[fixedSizeIndex].size);
DALI_LOG_INFO(gFontClientLogFilter, Debug::Verbose, " size index : %d, size : %d\n", fixedSizeIndex, fixedSize);
if(fixedSize >= requestedPointSize)
{
// The requested point size is bigger than the bigest fixed size.
fixedSizeIndex = ftFace->num_fixed_sizes - 1;
- actualPointSize = ftFace->available_sizes[fixedSizeIndex].size;
+ actualPointSize = static_cast<PointSize26Dot6>(ftFace->available_sizes[fixedSizeIndex].size);
}
DALI_LOG_INFO(gFontClientLogFilter, Debug::Verbose, " size index : %d, actual size : %d\n", fixedSizeIndex, actualPointSize);
return -1;
}
-int WindowBaseAndroid::GetOrientation() const
+int WindowBaseAndroid::GetWindowRotationAngle() const
{
return 0;
}
int CreateFramePresentedSyncFence() override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetPositionSizeWithAngle()
WindowOrientation GlWindow::GetCurrentOrientation() const
{
- DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mTotalRotationAngle);
return ConvertToOrientation(mTotalRotationAngle);
}
virtual void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) = 0;
/**
- * @brief Return the orientation of the surface.
- * @return The orientation
+ * @brief Return the angle of the window's rotation.
+ * @return The window orientation
*/
- virtual int GetOrientation() const = 0;
+ virtual int GetWindowRotationAngle() const = 0;
/**
- * @brief Get the screen rotation angle of the window
+ * @brief Get the angle of screen rotation for the window
+ * @return The screen orientation
*/
virtual int GetScreenRotationAngle() = 0;
/**
- * @brief Set the rotation angle of the window
+ * @brief Set the screen rotation angle of the window
*/
virtual void SetWindowRotationAngle(int degree) = 0;
mIconified(false),
mOpaqueState(false),
mWindowRotationAcknowledgement(false),
- mFocused(false)
+ mFocused(false),
+ mIsWindowRotating(false)
{
}
mWindowBase->AuxiliaryMessageSignal().Connect(this, &Window::OnAuxiliaryMessage);
mWindowSurface->OutputTransformedSignal().Connect(this, &Window::OnOutputTransformed);
+ mWindowSurface->RotationFinishedSignal().Connect(this, &Window::OnRotationFinished);
AddAuxiliaryHint("wm.policy.win.user.geometry", "1");
{
mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
}
+
+ if(positionSize.width <= 0 || positionSize.height <= 0)
+ {
+ mWindowWidth = screenWidth;
+ mWindowHeight = screenHeight;
+ }
+ else
+ {
+ mWindowWidth = positionSize.width;
+ mWindowHeight = positionSize.height;
+ }
+
// For Debugging
mNativeWindowId = mWindowBase->GetNativeWindowId();
}
void Window::SetSize(Dali::Window::WindowSize size)
{
- PositionSize oldRect = mSurface->GetPositionSize();
-
- mWindowSurface->MoveResize(PositionSize(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
+ PositionSize oldRect = GetPositionSize();
- PositionSize newRect = mSurface->GetPositionSize();
+ PositionSize newRect;
+ newRect.width = size.GetWidth();
+ newRect.height = size.GetHeight();
// When surface size is updated, inform adaptor of resizing and emit ResizeSignal
if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
{
+ mWindowSurface->MoveResize(PositionSize(oldRect.x, oldRect.y, newRect.width, newRect.height));
+
Uint16Pair newSize(newRect.width, newRect.height);
mWindowWidth = newRect.width;
mWindowHeight = newRect.height;
- SurfaceResized();
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetSize(): (%d, %d), [%d x %d]\n", this, mNativeWindowId, mRotationAngle, oldRect.x, oldRect.y, newRect.width, newRect.height);
- mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
+ SurfaceResized(static_cast<float>(mWindowWidth), static_cast<float>(mWindowHeight));
- DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.width, newRect.height);
+ mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
Dali::Window handle(this);
mResizeSignal.Emit(handle, newSize);
Dali::Window::WindowSize Window::GetSize() const
{
- PositionSize positionSize = mSurface->GetPositionSize();
-
- return Dali::Window::WindowSize(positionSize.width, positionSize.height);
+ return Dali::Window::WindowSize(mWindowWidth, mWindowHeight);
}
void Window::SetPosition(Dali::Window::WindowPosition position)
Dali::Window::WindowPosition Window::GetPosition() const
{
- PositionSize positionSize = mSurface->GetPositionSize();
-
+ PositionSize positionSize = GetPositionSize();
return Dali::Window::WindowPosition(positionSize.x, positionSize.y);
}
PositionSize Window::GetPositionSize() const
{
- return mSurface->GetPositionSize();
+ PositionSize positionSize = mSurface->GetPositionSize();
+ positionSize.width = mWindowWidth;
+ positionSize.height = mWindowHeight;
+ return positionSize;
}
void Window::SetPositionSize(PositionSize positionSize)
{
- PositionSize oldRect = mSurface->GetPositionSize();
+ bool moved = false;
+ bool resize = false;
+
+ PositionSize oldRect = GetPositionSize();
Dali::Window handle(this);
- mWindowSurface->MoveResize(positionSize);
+ if((oldRect.x != positionSize.x) || (oldRect.y != positionSize.y))
+ {
+ moved = true;
+ }
- PositionSize newRect = mSurface->GetPositionSize();
+ if((oldRect.width != positionSize.width) || (oldRect.height != positionSize.height))
+ {
+ resize = true;
+ }
- if((oldRect.x != newRect.x) || (oldRect.y != newRect.y))
+ if(moved || resize)
{
- Dali::Window::WindowPosition position(newRect.x, newRect.y);
+ mWindowSurface->MoveResize(positionSize);
+ }
+
+ // When window is moved, emit Moved Signal
+ if(moved)
+ {
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Moved signal emit (%d, %d)\n", this, mNativeWindowId, positionSize.x, positionSize.y);
+ Dali::Window::WindowPosition position(positionSize.x, positionSize.y);
mMovedSignal.Emit(handle, position);
}
// When surface size is updated, inform adaptor of resizing and emit ResizeSignal
- if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
+ if(resize)
{
- Uint16Pair newSize(newRect.width, newRect.height);
+ Uint16Pair newSize(positionSize.width, positionSize.height);
- mWindowWidth = newRect.width;
- mWindowHeight = newRect.height;
+ mWindowWidth = positionSize.width;
+ mWindowHeight = positionSize.height;
- SurfaceResized();
+ SurfaceResized(static_cast<float>(mWindowWidth), static_cast<float>(mWindowHeight));
mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
- DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.width, newRect.height);
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Resize signal emit [%d x %d]\n", this, mNativeWindowId, positionSize.width, positionSize.height);
+
mResizeSignal.Emit(handle, newSize);
mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
}
void Window::OnOutputTransformed()
{
- PositionSize positionSize = mSurface->GetPositionSize();
+ PositionSize positionSize = GetPositionSize();
- int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
- SurfaceRotated(static_cast<float>(positionSize.width), static_cast<float>(positionSize.height), orientation);
+ SurfaceRotated(static_cast<float>(positionSize.width), static_cast<float>(positionSize.height), mRotationAngle, mWindowBase->GetScreenRotationAngle());
mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
void Window::OnUpdatePositionSize(Dali::PositionSize& positionSize)
{
- bool resized = false;
- bool moved = false;
- Dali::Window handle(this);
- PositionSize oldRect = mSurface->GetPositionSize();
+ bool moved = false;
+ bool resize = false;
- mWindowSurface->UpdatePositionSize(positionSize);
+ Dali::Window handle(this);
+ PositionSize oldRect = GetPositionSize();
PositionSize newRect = positionSize;
if((oldRect.x != newRect.x) || (oldRect.y != newRect.y))
if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
{
- resized = true;
+ resize = true;
}
- if(moved)
+ if(moved || resize)
+ {
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), position or size is updated by server , (%d, %d) [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.x, newRect.y, newRect.width, newRect.height);
+ mWindowSurface->UpdatePositionSize(positionSize);
+ }
+
+ if((oldRect.x != newRect.x) || (oldRect.y != newRect.y))
{
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Moved signal emit (%d, %d)\n", this, mNativeWindowId, newRect.x, newRect.y);
Dali::Window::WindowPosition position(newRect.x, newRect.y);
mMovedSignal.Emit(handle, position);
}
// When surface size is updated, inform adaptor of resizing and emit ResizeSignal
- if(resized)
+ if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
{
Uint16Pair newSize(newRect.width, newRect.height);
mWindowWidth = newRect.width;
mWindowHeight = newRect.height;
- SurfaceResized();
+ SurfaceResized(static_cast<float>(mWindowWidth), static_cast<float>(mWindowHeight));
mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
- DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Updated PositionSize by server :resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height);
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Resized signal emit [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height);
mResizeSignal.Emit(handle, newSize);
mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
}
mWindowWidth = rotation.width;
mWindowHeight = rotation.height;
+ mIsWindowRotating = true;
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), angle(%d), Window Rotation (%d , %d) [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newPositionSize.x, newPositionSize.y, mWindowWidth, mWindowHeight);
+
// Notify that the orientation is changed
mOrientation->OnOrientationChange(rotation);
mWindowSurface->RequestRotation(mRotationAngle, newPositionSize);
- int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
- SurfaceRotated(mWindowWidth, mWindowHeight, orientation);
+ SurfaceRotated(static_cast<float>(mWindowWidth), static_cast<float>(mWindowHeight), mRotationAngle, mWindowBase->GetScreenRotationAngle());
mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
- DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), OnRotation(): x[%d], y[%d], resize signal emit [%d x %d]\n", this, mNativeWindowId, newPositionSize.x, newPositionSize.y, mWindowWidth, mWindowHeight);
- // Emit signal
Dali::Window handle(this);
mResizeSignal.Emit(handle, Dali::Window::WindowSize(mWindowWidth, mWindowHeight));
mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
}
+void Window::OnRotationFinished()
+{
+ mIsWindowRotating = false;
+ DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), window rotation is finised\n", this, mNativeWindowId);
+}
+
void Window::OnPause()
{
if(mEventHandler)
bool Window::IsWindowRotating() const
{
- return mWindowSurface->IsWindowRotating();
+ return mIsWindowRotating;
}
const Dali::KeyEvent& Window::GetLastKeyEvent() const
void OnAccessibilityDisabled();
/**
+ * Called when the window rotation is finished.
+ *
+ * This signal is emmit when window rotation is finisehd and WindowRotationCompleted() is called.
+ */
+ void OnRotationFinished();
+
+ /**
* @brief Set available orientation to window base.
*/
void SetAvailableAnlges(const std::vector<int>& angles);
bool mOpaqueState : 1;
bool mWindowRotationAcknowledgement : 1;
bool mFocused : 1;
+ bool mIsWindowRotating : 1; ///< The window rotating flag.
};
} // namespace Adaptor
mEGLContext(nullptr),
mColorDepth(isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24),
mOutputTransformedSignal(),
+ mWindowRotationFinishedSignal(),
mFrameCallbackInfoContainer(),
mBufferDamagedRects(),
mMutex(),
mDpiHorizontal(0),
mDpiVertical(0),
mOwnSurface(false),
- mWindowRotationFinished(true),
- mScreenRotationFinished(true),
- mResizeFinished(true),
- mDefaultScreenRotationAvailable(false),
mIsImeWindowSurface(false),
- mNeedWindowRotationAcknowledgement(false)
+ mNeedWindowRotationAcknowledgement(false),
+ mIsWindowOrientationChanging(false)
{
DALI_LOG_INFO(gWindowRenderSurfaceLogFilter, Debug::Verbose, "Creating Window\n");
Initialize(surface);
mWindowBase->OutputTransformedSignal().Connect(this, &WindowRenderSurface::OutputTransformed);
// Check screen rotation
- mScreenRotationAngle = mWindowBase->GetScreenRotationAngle();
- if(mScreenRotationAngle != 0)
+ int screenRotationAngle = mWindowBase->GetScreenRotationAngle();
+ if(screenRotationAngle != 0)
{
- mScreenRotationFinished = false;
- mResizeFinished = false;
- mDefaultScreenRotationAvailable = true;
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::Initialize, screen rotation is enabled, screen rotation angle:[%d]\n", mScreenRotationAngle);
+ OutputTransformed();
+ DALI_LOG_RELEASE_INFO("WindowRenderSurface::Initialize, screen rotation is enabled, screen rotation angle:[%d]\n", screenRotationAngle);
}
}
TriggerEventInterface::KEEP_ALIVE_AFTER_TRIGGER));
}
- mPositionSize = positionSize;
-
- mWindowRotationAngle = angle;
- mWindowRotationFinished = false;
- mResizeFinished = false;
+ mPositionSize.x = positionSize.x;
+ mPositionSize.y = positionSize.y;
- mWindowBase->SetWindowRotationAngle(mWindowRotationAngle);
+ mWindowBase->SetWindowRotationAngle(angle);
- DALI_LOG_RELEASE_INFO("angle = %d screen rotation = %d, flag = %d\n", mWindowRotationAngle, mScreenRotationAngle, mWindowRotationFinished);
+ DALI_LOG_RELEASE_INFO("start window rotation angle = %d screen rotation = %d\n", angle, mScreenRotationAngle);
}
WindowBase* WindowRenderSurface::GetWindowBase()
return mOutputTransformedSignal;
}
+WindowRenderSurface::RotationFinishedSignalType& WindowRenderSurface::RotationFinishedSignal()
+{
+ return mWindowRotationFinishedSignal;
+}
+
PositionSize WindowRenderSurface::GetPositionSize() const
{
return mPositionSize;
dpiVertical = mDpiVertical;
}
-int WindowRenderSurface::GetOrientation() const
+int WindowRenderSurface::GetSurfaceOrientation() const
{
- return mWindowBase->GetOrientation();
+ return mWindowBase->GetWindowRotationAngle();
+}
+
+int WindowRenderSurface::GetScreenOrientation() const
+{
+ return mWindowBase->GetScreenRotationAngle();
}
void WindowRenderSurface::InitializeGraphics()
// Create the EGL window
EGLNativeWindowType window = mWindowBase->CreateEglWindow(width, height);
- // Set screen rotation
- mScreenRotationFinished = false;
-
auto eglGraphics = static_cast<EglGraphics*>(mGraphics);
Internal::Adaptor::EglImplementation& eglImpl = eglGraphics->GetEglImplementation();
void WindowRenderSurface::UpdatePositionSize(Dali::PositionSize positionSize)
{
- bool needToMove = false;
- bool needToResize = false;
-
// Check moving
if((fabs(positionSize.x - mPositionSize.x) >= MINIMUM_DIMENSION_CHANGE) ||
(fabs(positionSize.y - mPositionSize.y) >= MINIMUM_DIMENSION_CHANGE))
{
- needToMove = true;
- }
+ mPositionSize.x = positionSize.x;
+ mPositionSize.y = positionSize.y;
- // Check resizing
- if((fabs(positionSize.width - mPositionSize.width) >= MINIMUM_DIMENSION_CHANGE) ||
- (fabs(positionSize.height - mPositionSize.height) >= MINIMUM_DIMENSION_CHANGE))
- {
- needToResize = true;
- }
-
- if(needToResize)
- {
- mResizeFinished = false;
- mPositionSize = positionSize;
+ DALI_LOG_RELEASE_INFO("Update Position by server (%d, %d)\n", mPositionSize.x, mPositionSize.y);
}
- else
- {
- if(needToMove)
- {
- mPositionSize = positionSize;
- }
- }
-
- DALI_LOG_INFO(gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::MoveResize: %d, %d, %d, %d\n", mPositionSize.x, mPositionSize.y, mPositionSize.width, mPositionSize.height);
}
void WindowRenderSurface::MoveResize(Dali::PositionSize positionSize)
{
- bool needToMove = false;
- bool needToResize = false;
-
- // Check moving
- if((fabs(positionSize.x - mPositionSize.x) >= MINIMUM_DIMENSION_CHANGE) ||
- (fabs(positionSize.y - mPositionSize.y) >= MINIMUM_DIMENSION_CHANGE))
- {
- needToMove = true;
- }
-
- // Check resizing
- if((fabs(positionSize.width - mPositionSize.width) >= MINIMUM_DIMENSION_CHANGE) ||
- (fabs(positionSize.height - mPositionSize.height) >= MINIMUM_DIMENSION_CHANGE))
- {
- needToResize = true;
- }
-
- if(needToResize)
- {
- if(needToMove)
- {
- mWindowBase->MoveResize(positionSize);
- }
- else
- {
- mWindowBase->Resize(positionSize);
- }
+ mPositionSize.x = positionSize.x;
+ mPositionSize.y = positionSize.y;
- mResizeFinished = false;
- mPositionSize = positionSize;
- }
- else
- {
- if(needToMove)
- {
- mWindowBase->Move(positionSize);
-
- mPositionSize = positionSize;
- }
- }
+ DALI_LOG_RELEASE_INFO("Update Position by client (%d, %d)\n", positionSize.x, positionSize.y);
- DALI_LOG_INFO(gWindowRenderSurfaceLogFilter, Debug::Verbose, "WindowRenderSurface::MoveResize: %d, %d, %d, %d\n", mPositionSize.x, mPositionSize.y, mPositionSize.width, mPositionSize.height);
+ mWindowBase->MoveResize(positionSize);
}
void WindowRenderSurface::StartRender()
Dali::Integration::Scene::FrameCallbackContainer callbacks;
Dali::Integration::Scene scene = mScene.GetHandle();
+
if(scene)
{
bool needFrameRenderedTrigger = false;
* Notice : PreRotation is not used in the latest tizen,
* because output transform event should be occured before egl window is not created.
*/
-
- if(mIsResizing || mDefaultScreenRotationAvailable)
+ if(scene && resizingSurface)
{
- int totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
+ int totalAngle = 0;
+ bool isScreenOrientationChanging = false;
- // Window rotate or screen rotate
- if(!mWindowRotationFinished || !mScreenRotationFinished)
+ if(mWindowRotationAngle != scene.GetCurrentSurfaceOrientation())
{
- mWindowBase->SetEglWindowBufferTransform(totalAngle);
+ mWindowRotationAngle = scene.GetCurrentSurfaceOrientation();
+ mIsWindowOrientationChanging = true;
+ }
+
+ if(mScreenRotationAngle != scene.GetCurrentScreenOrientation())
+ {
+ mScreenRotationAngle = scene.GetCurrentScreenOrientation();
+ isScreenOrientationChanging = true;
+ }
+ totalAngle = (mWindowRotationAngle + mScreenRotationAngle) % 360;
- // Reset only screen rotation flag
- mScreenRotationFinished = true;
+ DALI_LOG_RELEASE_INFO("Window/Screen orientation ard changed, WinOrientation[%d],flag[%d], ScreenOrientation[%d],flag[%d], total[%d]\n", mWindowRotationAngle, mIsWindowOrientationChanging, mScreenRotationAngle, isScreenOrientationChanging, totalAngle);
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::PreRender: Set rotation [%d] [%d]\n", mWindowRotationAngle, mScreenRotationAngle);
+ Rect<int> surfaceSize = scene.GetCurrentSurfaceRect();
+ //update surface size
+ mPositionSize.width = surfaceSize.width;
+ mPositionSize.height = surfaceSize.height;
+
+ DALI_LOG_RELEASE_INFO("Window is resizing, (%d, %d), [%d x %d]\n", mPositionSize.x, mPositionSize.y, mPositionSize.width, mPositionSize.height);
+
+ // Window rotate or screen rotate
+ if(mIsWindowOrientationChanging || isScreenOrientationChanging)
+ {
+ mWindowBase->SetEglWindowBufferTransform(totalAngle);
}
// Only window rotate
- if(!mWindowRotationFinished)
+ if(mIsWindowOrientationChanging)
{
mWindowBase->SetEglWindowTransform(mWindowRotationAngle);
}
// Resize case
- if(!mResizeFinished)
- {
- Dali::PositionSize positionSize;
- positionSize.x = mPositionSize.x;
- positionSize.y = mPositionSize.y;
- if(totalAngle == 0 || totalAngle == 180)
- {
- positionSize.width = mPositionSize.width;
- positionSize.height = mPositionSize.height;
- }
- else
- {
- positionSize.width = mPositionSize.height;
- positionSize.height = mPositionSize.width;
- }
- mWindowBase->ResizeEglWindow(positionSize);
- mResizeFinished = true;
+ Dali::PositionSize positionSize;
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::PreRender: Set resize, totalAngle: %d, x: %d, y: %d, w: %d, h:%d\n", totalAngle, positionSize.x, positionSize.y, positionSize.width, positionSize.height);
+ // Some native resize API(wl_egl_window_resize) has the input parameters of x, y, width and height.
+ // So, position data should be set.
+ positionSize.x = mPositionSize.x;
+ positionSize.y = mPositionSize.y;
+ if(totalAngle == 0 || totalAngle == 180)
+ {
+ positionSize.width = mPositionSize.width;
+ positionSize.height = mPositionSize.height;
+ }
+ else
+ {
+ positionSize.width = mPositionSize.height;
+ positionSize.height = mPositionSize.width;
}
+ mWindowBase->ResizeEglWindow(positionSize);
+
SetFullSwapNextFrame();
- mDefaultScreenRotationAvailable = false;
}
SetBufferDamagedRects(damagedRects, clippingRect);
bool needWindowRotationCompleted = false;
- if(!mWindowRotationFinished)
+ if(mIsWindowOrientationChanging)
{
if(mNeedWindowRotationAcknowledgement)
{
}
else
{
- if(mIsResizing)
- {
- needWindowRotationCompleted = true;
- }
+ needWindowRotationCompleted = true;
}
}
mThreadSynchronization->PostRenderStarted();
}
- if(!mWindowRotationFinished || mIsImeWindowSurface)
+ if(mIsWindowOrientationChanging || mIsImeWindowSurface)
{
mPostRenderTrigger->Trigger();
}
if(mScreenRotationAngle != screenRotationAngle)
{
- mScreenRotationAngle = screenRotationAngle;
- mScreenRotationFinished = false;
- mResizeFinished = false;
-
mOutputTransformedSignal.Emit();
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::OutputTransformed: window = %d screen = %d\n", mWindowRotationAngle, mScreenRotationAngle);
+ DALI_LOG_RELEASE_INFO("WindowRenderSurface::OutputTransformed: window = %d new screen angle = %d\n", mWindowRotationAngle, screenRotationAngle);
}
else
{
}
}
-bool WindowRenderSurface::IsWindowRotating() const
-{
- return !(mWindowRotationFinished);
-}
-
void WindowRenderSurface::ProcessPostRender()
{
- if(!mWindowRotationFinished)
+ if(mIsWindowOrientationChanging)
{
+ mWindowRotationFinishedSignal.Emit();
mWindowBase->WindowRotationCompleted(mWindowRotationAngle, mPositionSize.width, mPositionSize.height);
- mWindowRotationFinished = true;
- DALI_LOG_RELEASE_INFO("WindowRenderSurface::ProcessPostRender: Rotation Done, flag = %d\n", mWindowRotationFinished);
+ mIsWindowOrientationChanging = false;
+ DALI_LOG_RELEASE_INFO("WindowRenderSurface::ProcessPostRender: Rotation Done, flag = %d\n", mIsWindowOrientationChanging);
}
if(mIsImeWindowSurface)
class WindowRenderSurface : public Dali::RenderSurfaceInterface, public ConnectionTracker
{
public:
- using OutputSignalType = Signal<void()>;
- using DamagedRectsContainer = std::vector<Rect<int>>;
+
+ using RotationFinishedSignalType = Signal<void()> ; ///<The signal of window rotation's finished.
+ using OutputSignalType = Signal<void()>;
+ using DamagedRectsContainer = std::vector<Rect<int>>;
/**
* Uses an window surface to render to.
void UpdatePositionSize(Dali::PositionSize positionSize);
/**
- * @brief Query whether window is rotating or not.
- *
- * @return true if window is rotating, false otherwise.
+ * @brief This signal is emitted when the output is transformed.
*/
- bool IsWindowRotating() const;
+ OutputSignalType& OutputTransformedSignal();
/**
- * @brief This signal is emitted when the output is transformed.
+ * @brief This signal is emitted when a rotation job is finished.
*/
- OutputSignalType& OutputTransformedSignal();
+ RotationFinishedSignalType& RotationFinishedSignal();
public: // from Dali::RenderSurfaceInterface
/**
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::RenderSurfaceInterface::GetOrientation()
+ * @copydoc Dali::RenderSurfaceInterface::GetSurfaceOrientation()
+ */
+ int GetSurfaceOrientation() const override;
+
+ /**
+ * @copydoc Dali::RenderSurfaceInterface::GetScreenOrientation()
*/
- int GetOrientation() const override;
+ int GetScreenOrientation() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
EGLSurface mEGLSurface;
EGLContext mEGLContext;
ColorDepth mColorDepth; ///< Color depth of surface (32 bit or 24 bit)
- OutputSignalType mOutputTransformedSignal;
+ OutputSignalType mOutputTransformedSignal; ///< The signal of screen rotation occurs
+ RotationFinishedSignalType mWindowRotationFinishedSignal; ///< The signal of window rotation's finished
FrameCallbackInfoContainer mFrameCallbackInfoContainer;
DamagedRectsContainer mBufferDamagedRects;
Dali::Mutex mMutex;
uint32_t mDpiVertical;
std::vector<Rect<int>> mDamagedRects{}; ///< Keeps collected damaged render items rects for one render pass. These rects are rotated by scene orientation.
bool mOwnSurface; ///< Whether we own the surface (responsible for deleting it)
- bool mWindowRotationFinished;
- bool mScreenRotationFinished;
- bool mResizeFinished;
- bool mDefaultScreenRotationAvailable;
bool mIsImeWindowSurface;
bool mNeedWindowRotationAcknowledgement;
+ bool mIsWindowOrientationChanging;
}; // class WindowRenderSurface
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
dpiVertical = res.height;
}
-int WindowBaseCocoa::GetOrientation() const
+int WindowBaseCocoa::GetWindowRotationAngle() const
{
return 0;
}
dpiVertical = int(yres + 0.5f);
}
-int WindowBaseEcoreWl::GetOrientation() const
+int WindowBaseEcoreWl::GetWindowRotationAngle() const
{
- int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
+ int orientation = mWindowRotationAngle;
if(mSupportedPreProtation)
{
orientation = 0;
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
ecore_wl2_window_geometry_set(mEcoreWindow, mWindowPositionSize.x, mWindowPositionSize.y, mWindowPositionSize.width, mWindowPositionSize.height);
Dali::PositionSize newPositionSize = RecalculatePositionSizeToCurrentOrientation(mWindowPositionSize);
- DALI_LOG_RELEASE_INFO("emit signal to update window's position and size, x[%d] y[%d] w[%d] h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
mUpdatePositionSizeSignal.Emit(newPositionSize);
}
}
}
+ DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_buffer_transform() with buffer Transform [%d]\n", bufferTransform);
wl_egl_window_tizen_set_buffer_transform(mEglWindow, bufferTransform);
}
}
}
+ DALI_LOG_RELEASE_INFO("wl_egl_window_tizen_set_window_transform() with window Transform [%d]\n", windowTransform);
wl_egl_window_tizen_set_window_transform(mEglWindow, windowTransform);
}
void WindowBaseEcoreWl2::ResizeEglWindow(PositionSize positionSize)
{
+ DALI_LOG_RELEASE_INFO("wl_egl_window_resize(), (%d, %d) [%d x %d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height);
wl_egl_window_resize(mEglWindow, positionSize.width, positionSize.height, positionSize.x, positionSize.y);
// Note: Both "Resize" and "MoveResize" cases can reach here, but only "MoveResize" needs to submit serial number
newPositionSize.height = positionSize.height;
}
- DALI_LOG_RELEASE_INFO("input coord x[%d], y[%d], w{%d], h[%d], screen w[%d], h[%d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height, mScreenWidth, mScreenHeight);
- DALI_LOG_RELEASE_INFO("recalc coord x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
-
return newPositionSize;
}
newPositionSize.height = positionSize.height;
}
- DALI_LOG_RELEASE_INFO("input coord x[%d], y[%d], w{%d], h[%d], screen w[%d], h[%d]\n", positionSize.x, positionSize.y, positionSize.width, positionSize.height, mScreenWidth, mScreenHeight);
- DALI_LOG_RELEASE_INFO("recalc by current orientation coord x[%d], y[%d], w{%d], h[%d]\n", newPositionSize.x, newPositionSize.y, newPositionSize.width, newPositionSize.height);
-
return newPositionSize;
}
dpiVertical = int(yres + 0.5f);
}
-int WindowBaseEcoreWl2::GetOrientation() const
+int WindowBaseEcoreWl2::GetWindowRotationAngle() const
{
- int orientation = (mScreenRotationAngle + mWindowRotationAngle) % 360;
+ int orientation = mWindowRotationAngle;
if(mSupportedPreProtation)
{
orientation = 0;
int WindowBaseEcoreWl2::GetScreenRotationAngle()
{
- int transform = 0;
-
+ if(mSupportedPreProtation)
+ {
+ DALI_LOG_RELEASE_INFO("Support PreRotation and return 0\n");
+ return 0;
+ }
+ int transform;
if(ecore_wl2_window_ignore_output_transform_get(mEcoreWindow))
{
transform = 0;
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
dpiVertical = int(yres + 0.5f);
}
-int NativeRenderSurfaceEcoreWl::GetOrientation() const
+int NativeRenderSurfaceEcoreWl::GetSurfaceOrientation() const
+{
+ return 0;
+}
+
+int NativeRenderSurfaceEcoreWl::GetScreenOrientation() const
{
return 0;
}
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::RenderSurfaceInterface::GetOrientation()
+ * @copydoc Dali::RenderSurfaceInterface::GetSurfaceOrientation()
*/
- int GetOrientation() const override;
+ int GetSurfaceOrientation() const override;
+
+ /**
+ * @copydoc Dali::RenderSurfaceInterface::GetScreenOrientation()
+ */
+ int GetScreenOrientation() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
dpiVertical = int(yres + 0.5f);
}
-int PixmapRenderSurfaceEcoreX::GetOrientation() const
+int PixmapRenderSurfaceEcoreX::GetSurfaceOrientation() const
+{
+ return 0;
+}
+
+int PixmapRenderSurfaceEcoreX::GetScreenOrientation() const
{
return 0;
}
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::RenderSurfaceInterface::GetSurfaceOrientation()
*/
- int GetOrientation() const override;
+ int GetSurfaceOrientation() const override;
+
+ /**
+ * @copydoc Dali::RenderSurfaceInterface::GetScreenOrientation()
+ */
+ int GetScreenOrientation() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
dpiVertical = ecore_x_dpi_get();
}
-int WindowBaseEcoreX::GetOrientation() const
+int WindowBaseEcoreX::GetWindowRotationAngle() const
{
return 0;
}
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
{
}
-int WindowBaseWin::GetOrientation() const
+int WindowBaseWin::GetWindowRotationAngle() const
{
return 0;
}
void SetTransparency(bool transparent) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::SetParent()
WindowSystem::GetImplementation().GetDPI(dpiHorizontal, dpiVertical);
}
-int PixmapRenderSurfaceX::GetOrientation() const
+int PixmapRenderSurfaceX::GetSurfaceOrientation() const
+{
+ return 0;
+}
+
+int PixmapRenderSurfaceX::GetScreenOrientation() const
{
return 0;
}
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::RenderSurfaceInterface::GetSurfaceOrientation()
*/
- int GetOrientation() const override;
+ int GetSurfaceOrientation() const override;
+
+ /**
+ * @copydoc Dali::RenderSurfaceInterface::GetScreenOrientation()
+ */
+ int GetScreenOrientation() const override;
/**
* @copydoc Dali::RenderSurfaceInterface::InitializeGraphics()
WindowSystem::GetImplementation().GetDPI(dpiHorizontal, dpiVertical);
}
-int WindowBaseX::GetOrientation() const
+int WindowBaseX::GetWindowRotationAngle() const
{
return 0;
}
void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) override;
/**
- * @copydoc Dali::Internal::Adaptor::WindowBase::GetOrientation()
+ * @copydoc Dali::Internal::Adaptor::WindowBase::GetWindowRotationAngle()
*/
- int GetOrientation() const override;
+ int GetWindowRotationAngle() const override;
/**
* @copydoc Dali::Internal::Adaptor::WindowBase::GetScreenRotationAngle()
projects / platform / core / uifw / dali-adaptor.git / commitdiff