Applied float point

Change-Id: Ibc617feb4a3fd62363a45bd9d9f33e2d942a8007
Signed-off-by: HeeJu Kang <mobum.kang@samsung.com>

diff --git a/inc/FShellLiveboxFrame.h b/inc/FShellLiveboxFrame.h
index 4c2c2a5..34ab138 100644 (file)
--- a/inc/FShellLiveboxFrame.h
+++ b/inc/FShellLiveboxFrame.h
@@ -69,6 +69,18 @@ public:
         */
        result Construct(const Tizen::Graphics::Dimension& size);
 
+       /*\r
+       * Initializes this instance of %LiveboxFrame with the specified parameter.\r
+       *\r
+       * @since       2.1\r
+       * @return      An error code\r
+       * @param[in]   size                                     The new width and height\r
+       * @exception   E_SUCCESS                        The method is successful.\r
+       * @exception   E_INVALID_ARG            A specified input parameter is invalid.\r
+       * @see LiveboxProvider::OnLiveboxProviderInitialize()\r
+       */\r
+       result ConstructF(const Tizen::Graphics::FloatDimension& size);
+
        /**
         * Initializes this instance of %LiveboxFrame with the specified parameter.
         *
@@ -82,6 +94,19 @@ public:
         */
        result Construct(const Tizen::Ui::Layout& layout, const Tizen::Graphics::Dimension& size);
 
+       /*\r
+        * Initializes this instance of %LiveboxFrame with the specified parameter.\r
+        *\r
+        * @since       2.1\r
+        * @return      An error code\r
+        * @param[in]   layout                          The layout for both the portrait and landscape mode\r
+        * @param[in]   size                            The new width and height\r
+        * @exception   E_SUCCESS           The method is successful.\r
+        * @exception   E_INVALID_ARG           A specified input parameter is invalid.\r
+        * @see LiveboxProvider::OnLiveboxProviderInitialize()\r
+        */\r
+       result ConstructF(const Tizen::Ui::Layout& layout, const Tizen::Graphics::FloatDimension& size);
+
 protected:
        //
        // This method is for internal use only. Using this method can cause behavioral, security-related,

diff --git a/inc/FShellLiveboxPopup.h b/inc/FShellLiveboxPopup.h
index 00d8a51..7589983 100644 (file)
--- a/inc/FShellLiveboxPopup.h
+++ b/inc/FShellLiveboxPopup.h
@@ -69,6 +69,18 @@ public:
         */
        result Construct(const Tizen::Graphics::Dimension& size);
 
+       /*\r
+        * Initializes this instance of %LiveboxFrame with the specified parameter.\r
+        *\r
+        * @since       2.1\r
+        * @return      An error code\r
+        * @param[in]   size                            The new width and height\r
+        * @exception   E_SUCCESS           The method is successful.\r
+        * @exception   E_INVALID_ARG           A specified input parameter is invalid.\r
+        * @see LiveboxProvider::OnLiveboxPopupProviderInitialize()\r
+        */\r
+       result ConstructF(const Tizen::Graphics::FloatDimension& size);\r
+
        /**
         * Initializes this instance of %LiveboxFrame with the specified parameter.
         *
@@ -82,6 +94,103 @@ public:
         */
        result Construct(const Tizen::Ui::Layout& layout, const Tizen::Graphics::Dimension& size);
 
+       /*\r
+        * Initializes this instance of %LiveboxFrame with the specified parameter.\r
+        *\r
+        * @since       2.1\r
+        * @return      An error code\r
+        * @param[in]   layout                          The layout for both the portrait and landscape mode\r
+        * @param[in]   size                            The new width and height\r
+        * @exception   E_SUCCESS           The method is successful.\r
+        * @exception   E_INVALID_ARG           A specified input parameter is invalid.\r
+        * @see LiveboxProvider::OnLiveboxPopupProviderInitialize()\r
+        */\r
+       result ConstructF(const Tizen::Ui::Layout& layout, const Tizen::Graphics::FloatDimension& size);\r
+
+       /*\r
+        * Gets the bounds of the client area.\r
+        *\r
+        * @since               2.1\r
+        *\r
+        * @return              The bounds of the client area in a Rectangle instance\r
+        */\r
+       Tizen::Graphics::Rectangle GetClientAreaBounds(void) const;\r
+\r
+       /*\r
+        * Gets the bounds of the client area.\r
+        *\r
+        * @since               2.1\r
+        *\r
+        * @return              The bounds of the client area in a FloatRectangle instance\r
+        */\r
+       Tizen::Graphics::FloatRectangle GetClientAreaBoundsF(void) const;\r
+\r
+       /*\r
+        * Creates and returns a graphics canvas whose bounds (position and size) are equal to the bounds of the client area of the %LiveboxPopup.\r
+        *\r
+        * @since              2.1\r
+        *\r
+        * @return             The graphic canvas of the %LiveboxPopup, @n\r
+        *                            else @c null if an error occurs\r
+        * @exception  E_SUCCESS                                        The method is successful.\r
+        * @exception  E_RESOURCE_UNAVAILABLE           The required resource is currently unavailable.\r
+        * @remarks            The method allocates a Tizen::Graphics::Canvas whose bounds are equal to that of the client area of the % LiveboxPopup. @n\r
+        *                            It is the responsibility of the developers to deallocate the canvas after use.\r
+        * @remarks            The canvas is valid only if the properties of the parent control of the canvas remain unchanged. @n\r
+        *                            Therefore, delete the previously allocated canvas and create a new canvas using the GetCanvasN() method if the size or position of the\r
+        *                            control is changed.\r
+        * @remarks            The specific error code can be accessed using the GetLastResult() method.\r
+        */\r
+       Tizen::Graphics::Canvas* GetClientAreaCanvasN(void) const;\r
+\r
+       /*\r
+        * Translates the specified position to the client coordinates.\r
+        *\r
+        * @since       2.1\r
+        *\r
+        * @return      The position in relative to the top-left corner of the client-area, @n\r
+        *                            else @c (-1,-1) if the instance is invalid\r
+        * @param[in]   position       The position relative to the top-left corner of the %LiveboxPopup.\r
+        * @see         TranslateFromClientAreaPosition()\r
+        */\r
+       Tizen::Graphics::Point TranslateToClientAreaPosition(const Tizen::Graphics::Point& position) const;\r
+\r
+       /*\r
+        * Translates the specified position to the client coordinates.\r
+        *\r
+        * @since       2.1\r
+        *\r
+        * @return      The float position in relative to the top-left corner of the client-area, @n\r
+        *                            else @c (-1.0f,-1.0f) if the instance is invalid\r
+        * @param[in]   position       The float position relative to the top-left corner of the %LiveboxPopup.\r
+        * @see         TranslateFromClientAreaPositionF()\r
+        */\r
+       Tizen::Graphics::FloatPoint TranslateToClientAreaPositionF(const Tizen::Graphics::FloatPoint& position) const;\r
+\r
+       /*\r
+        * Translates the specified client position to the control coordinate.\r
+        *\r
+        * @since       2.1\r
+        *\r
+        * @return      The position in relative to the top-left corner of the %Popup control, @n\r
+        *                            else @c (-1,-1) if the instance is invalid\r
+        * @param[in]   clientPosition        The position relative to the top-left corner of the client area\r
+        * @see         TranslateToClientAreaPosition()\r
+        */\r
+       Tizen::Graphics::Point TranslateFromClientAreaPosition(const Tizen::Graphics::Point& clientPosition) const;\r
+\r
+       /*\r
+        * Translates the specified client position to the control coordinate.\r
+        *\r
+        * @since       2.1\r
+        *\r
+        * @return      The float position in relative to the top-left corner of the %Popup control, @n\r
+        *                            else @c (-1.0f,-1.0f) if the instance is invalid\r
+        * @param[in]   clientPosition        The float position relative to the top-left corner of the client area\r
+        * @see         TranslateToClientAreaPositionF()\r
+        */\r
+       Tizen::Graphics::FloatPoint TranslateFromClientAreaPositionF(const Tizen::Graphics::FloatPoint& clientPosition) const;
+
 protected:
        //
        // This method is for internal use only. Using this method can cause behavioral, security-related,

diff --git a/inc/FShellLiveboxView.h b/inc/FShellLiveboxView.h
index ef70de2..1cf05c5 100644 (file)
--- a/inc/FShellLiveboxView.h
+++ b/inc/FShellLiveboxView.h
@@ -80,6 +80,23 @@ public:
         */
        result Construct(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect);
 
+       /*\r
+        * Initializes this instance of %LiveboxView with the specified parameter.\r
+        *\r
+        * @since       2.1\r
+        * @return      An error code\r
+        * @param[in]   appId                           The AppId of the installed application\r
+        * @param[in]   providerName            The name of the Livebox provider\r
+        * @param[in]   rect                            An instance of the FloatRectangle class @n\r
+        *                                                                      This instance represents the x and y coordinates of the top-left corner @n\r
+        *                                                                      of the created window along with its width and height. @n\r
+        * @exception   E_SUCCESS           The method is successful.\r
+        * @exception   E_INVALID_ARG           A specified input parameter is invalid.\r
+        * @exception   E_APP_NOT_INSTALLED     The application is not installed.\r
+        * @exception   E_OBJ_NOT_FOUND         The specified Livebox provider is not found.\r
+        */\r
+       result ConstructF(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect);\r
+
        /**
         * Initializes this instance of %LiveboxView with the specified parameter.
         *
@@ -98,6 +115,24 @@ public:
         */
        result Construct(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const Tizen::Base::String& userInfo);
 
+       /**\r
+        * Initializes this instance of %LiveboxView with the specified parameter.\r
+        *\r
+        * @since       2.1\r
+        * @return      An error code\r
+        * @param[in]   appId                           The AppId of the installed application\r
+        * @param[in]   providerName            The name of the Livebox provider\r
+        * @param[in]   rect                            An instance of the FloatRectangle class @n\r
+        *                                                                      This instance represents the x and y coordinates of the top-left corner @n\r
+        *                                                                      of the created window along with its width and height. @n\r
+        * @param[in]   userInfo                        Extra data to be delivered to Livebox provider\r
+        * @exception   E_SUCCESS           The method is successful.\r
+        * @exception   E_INVALID_ARG           A specified input parameter is invalid.\r
+        * @exception   E_APP_NOT_INSTALLED     The application is not installed.\r
+        * @exception   E_OBJ_NOT_FOUND         The specified Livebox provider is not found.\r
+        */\r
+       result ConstructF(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect, const Tizen::Base::String& userInfo);\r
+
 protected:
        //
        // This method is for internal use only. Using this method can cause behavioral, security-related,

diff --git a/src/FShellLiveboxFrame.cpp b/src/FShellLiveboxFrame.cpp
index fcacabb..a680816 100644 (file)
--- a/src/FShellLiveboxFrame.cpp
+++ b/src/FShellLiveboxFrame.cpp
@@ -43,6 +43,12 @@ LiveboxFrame::~LiveboxFrame(void)
 result
 LiveboxFrame::Construct(const Dimension& size)
 {
+       return ConstructF(FloatDimension(static_cast<float>(size.width), static_cast<float>(size.height)));
+}
+
+result
+LiveboxFrame::ConstructF(const FloatDimension& size)
+{
        SysAssertf(_pControlImpl == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
        unique_ptr<_LiveboxFrameImpl> pImpl(_LiveboxFrameImpl::CreateLiveboxFrameImplN(*this, null, null));
        result r = GetLastResult();
@@ -59,6 +65,12 @@ LiveboxFrame::Construct(const Dimension& size)
 result
 LiveboxFrame::Construct(const Layout& layout, const Dimension& size)
 {
+       return ConstructF(layout, FloatDimension(static_cast<float>(size.width), static_cast<float>(size.height)));
+}
+
+result
+LiveboxFrame::ConstructF(const Layout& layout, const FloatDimension& size)
+{
        SysAssertf(_pControlImpl == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
 
        unique_ptr<_LiveboxFrameImpl> pImpl(_LiveboxFrameImpl::CreateLiveboxFrameImplN(*this, &layout, &layout));

diff --git a/src/FShellLiveboxPopup.cpp b/src/FShellLiveboxPopup.cpp
index e90250c..0bb5e9f 100644 (file)
--- a/src/FShellLiveboxPopup.cpp
+++ b/src/FShellLiveboxPopup.cpp
@@ -43,6 +43,12 @@ LiveboxPopup::~LiveboxPopup(void)
 result
 LiveboxPopup::Construct(const Dimension& size)
 {
+       return ConstructF(FloatDimension(static_cast<float>(size.width), static_cast<float>(size.height)));
+}
+
+result
+LiveboxPopup::ConstructF(const FloatDimension& size)
+{
        SysAssertf(_pControlImpl == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
 
        unique_ptr<_LiveboxPopupImpl> pImpl(_LiveboxPopupImpl::CreateLiveboxPopupImplN(*this, null, null));
@@ -60,6 +66,12 @@ LiveboxPopup::Construct(const Dimension& size)
 result
 LiveboxPopup::Construct(const Layout& layout, const Dimension& size)
 {
+       return ConstructF(layout, FloatDimension(static_cast<float>(size.width), static_cast<float>(size.height)));
+}
+
+result
+LiveboxPopup::ConstructF(const Layout& layout, const FloatDimension& size)
+{
        SysAssertf(_pControlImpl == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class.");
 
        unique_ptr<_LiveboxPopupImpl> pImpl(_LiveboxPopupImpl::CreateLiveboxPopupImplN(*this, &layout, &layout));
@@ -74,4 +86,68 @@ LiveboxPopup::Construct(const Layout& layout, const Dimension& size)
        return r;
 }
 
+Rectangle\r
+LiveboxPopup::GetClientAreaBounds(void) const\r
+{\r
+       FloatRectangle floatRect = GetClientAreaBoundsF();\r
+\r
+       return Rectangle(floatRect.x, floatRect.y, floatRect.width, floatRect.height);\r
+}\r
+\r
+FloatRectangle\r
+LiveboxPopup::GetClientAreaBoundsF(void) const\r
+{\r
+       const _LiveboxPopupImpl* pImpl = _LiveboxPopupImpl::GetInstance(*this);
+       SysAssertf(pImpl != null, "Not yet constructed. Construct() should be called before use.");\r
+\r
+       return pImpl->GetClientAreaBounds();\r
+}\r
+\r
+Canvas*\r
+LiveboxPopup::GetClientAreaCanvasN(void) const\r
+{\r
+       const _LiveboxPopupImpl* pImpl = _LiveboxPopupImpl::GetInstance(*this);
+       SysAssertf(pImpl != null, "Not yet constructed. Construct() should be called before use.");\r
+\r
+       Canvas* pCanvas = pImpl->GetClientAreaCanvasN();\r
+       result r = GetLastResult();\r
+       SysTryReturn(NID_UI_CTRL, pCanvas, null, r, "[%s] Propagating.", GetErrorMessage(r));\r
+\r
+       return pCanvas;\r
+}\r
+\r
+Point\r
+LiveboxPopup::TranslateToClientAreaPosition(const Point& position) const\r
+{\r
+       FloatPoint floatPoint = TranslateToClientAreaPositionF(FloatPoint(static_cast<float>(position.x), static_cast<float>(position.y)));\r
+\r
+       return Point(floatPoint.x, floatPoint.y);\r
+}\r
+\r
+FloatPoint\r
+LiveboxPopup::TranslateToClientAreaPositionF(const FloatPoint& position) const\r
+{\r
+       const _LiveboxPopupImpl* pImpl = _LiveboxPopupImpl::GetInstance(*this);
+       SysAssertf(pImpl != null, "Not yet constructed. Construct() should be called before use.");\r
+\r
+       return pImpl->TranslateToClientAreaPosition(position);\r
+}\r
+\r
+Point\r
+LiveboxPopup::TranslateFromClientAreaPosition(const Point& clientPosition) const\r
+{\r
+       FloatPoint floatPoint = TranslateFromClientAreaPositionF(FloatPoint(static_cast<float>(clientPosition.x), static_cast<float>(clientPosition.y)));\r
+\r
+       return Point(floatPoint.x, floatPoint.y);\r
+}\r
+\r
+FloatPoint
+LiveboxPopup::TranslateFromClientAreaPositionF(const FloatPoint& clientPosition) const
+{
+       const _LiveboxPopupImpl* pImpl = _LiveboxPopupImpl::GetInstance(*this);
+       SysAssertf(pImpl != null, "Not yet constructed. Construct() should be called before use.");
+
+       return pImpl->TranslateFromClientAreaPosition(clientPosition);
+}
+
 }} // Tizen::Shell

diff --git a/src/FShellLiveboxView.cpp b/src/FShellLiveboxView.cpp
index fbc8b13..dc2aac3 100644 (file)
--- a/src/FShellLiveboxView.cpp
+++ b/src/FShellLiveboxView.cpp
@@ -44,13 +44,25 @@ LiveboxView::~LiveboxView(void)
 }
 
 result
-LiveboxView::Construct(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect)
+LiveboxView::Construct(const AppId& appId, const String& providerName, const Rectangle& rect)
 {
-       return Construct(appId, providerName, rect, L"");
+       return ConstructF(appId, providerName, FloatRectangle(static_cast<float>(rect.x), static_cast<float>(rect.y), static_cast<float>(rect.width), static_cast<float>(rect.height)), L"");
 }
 
 result
-LiveboxView::Construct(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const String& userInfo)
+LiveboxView::ConstructF(const AppId& appId, const String& providerName, const FloatRectangle& rect)
+{
+       return ConstructF(appId, providerName, rect, L"");
+}
+
+result
+LiveboxView::Construct(const AppId& appId, const String& providerName, const Rectangle& rect, const String& userInfo)
+{
+       return ConstructF(appId, providerName, FloatRectangle(static_cast<float>(rect.x), static_cast<float>(rect.y), static_cast<float>(rect.width), static_cast<float>(rect.height)), userInfo);
+}
+
+result
+LiveboxView::ConstructF(const AppId& appId, const String& providerName, const FloatRectangle& rect, const String& userInfo)
 {
        SysTryReturnResult(NID_UI_CTRL, _Aul::IsInstalled(appId) == true, E_APP_NOT_INSTALLED, "The application is not installed.");
 

diff --git a/src/FShell_LiveboxFrame.cpp b/src/FShell_LiveboxFrame.cpp
index 89957b6..7444e1c 100644 (file)
--- a/src/FShell_LiveboxFrame.cpp
+++ b/src/FShell_LiveboxFrame.cpp
@@ -96,14 +96,14 @@ _LiveboxFrame::CreateLiveboxFrameN(void)
 }
 
 result
-_LiveboxFrame::Initialize(const Dimension& size)
+_LiveboxFrame::Initialize(const FloatDimension& size)
 {
        result r = E_SUCCESS;
 
-       const int DEFAULT_WIDTH = 172;
-       const int DEFAULT_HEIGHT = 172;
+       const float DEFAULT_WIDTH = 172.0f;
+       const float DEFAULT_HEIGHT = 172.0f;
 
-       Dimension liveboxSize(size);
+       FloatDimension liveboxSize(size);
        if (liveboxSize.width <= 0 )
        {
                liveboxSize.width = DEFAULT_WIDTH;
@@ -141,8 +141,8 @@ _LiveboxFrame::Initialize(const Dimension& size)
        __pLiveboxFrameRootVisualElement->AttachChild(*pVisualElement);
 #endif // MULTI_WINDOW
 
-       Rectangle bounds(0, 0, liveboxSize.width, liveboxSize.height);
-       r = SetBounds(bounds);
+       FloatRectangle bounds(0.0f, 0.0f, liveboxSize.width, liveboxSize.height);
+       r = SetBoundsF(bounds);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
        r = __pLiveboxFramePresenter->Initialize();
@@ -151,11 +151,9 @@ _LiveboxFrame::Initialize(const Dimension& size)
        __pLiveboxLayer->SetLayerBounds(bounds);
        __pLiveboxLayer->SetShowState(false);
 
-       FloatRectangle fBounds(0.0f, 0.0f, static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-
        __pLiveboxFrameRootVisualElement->SetImplicitAnimationEnabled(false);
        __pLiveboxFrameRootVisualElement->SetName(L"_LiveboxFrame");
-       __pLiveboxFrameRootVisualElement->SetBounds(fBounds);
+       __pLiveboxFrameRootVisualElement->SetBounds(bounds);
        __pLiveboxFrameRootVisualElement->SetShowState(false);
 
        SetBackgroundColor(Color(0, 0, 0, 0));
@@ -203,7 +201,7 @@ _LiveboxFrame::SetLayerShowState(bool showState)
 }
 
 result
-_LiveboxFrame::SetLayerBounds(const Rectangle& bounds)
+_LiveboxFrame::SetLayerBounds(const FloatRectangle& bounds)
 {
        result r = E_SUCCESS;
 
@@ -214,9 +212,7 @@ _LiveboxFrame::SetLayerBounds(const Rectangle& bounds)
                SysTryReturn(NID_UI_CTRL, pLayer, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
                pLayer->SetLayerBounds(bounds);
-
-               FloatRectangle fBounds(0.0f, 0.0f, static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-               __pLiveboxFrameRootVisualElement->SetBounds(fBounds);
+               __pLiveboxFrameRootVisualElement->SetBounds(bounds);
        }
 
        return r;
@@ -257,9 +253,9 @@ _LiveboxFrame::OnDeactivated(void)
 void
 _LiveboxFrame::OnBoundsChanged(void)
 {
-       Rectangle bounds = GetBounds();
+       FloatRectangle bounds = GetBoundsF();
 
-       SetLayerBounds(bounds);
+       SetLayerBounds(GetBoundsF());
 }
 
 void

diff --git a/src/FShell_LiveboxFrame.h b/src/FShell_LiveboxFrame.h
index 5277027..aab548e 100644 (file)
--- a/src/FShell_LiveboxFrame.h
+++ b/src/FShell_LiveboxFrame.h
@@ -55,7 +55,7 @@ public:
        static _LiveboxFrame* CreateLiveboxFrameN(void);
        virtual ~_LiveboxFrame(void);
 
-       result Initialize(const Tizen::Graphics::Dimension& size);
+       result Initialize(const Tizen::Graphics::FloatDimension& size);
        result SetProviderId(const Tizen::Base::String& providerId);
        Tizen::Base::String GetProviderId(void) const;
 
@@ -67,7 +67,7 @@ private:
        _LiveboxFrame& operator =(const _LiveboxFrame&  rhs);
 
        result SetLayerShowState(bool showState);
-       result SetLayerBounds(const Tizen::Graphics::Rectangle& bounds);
+       result SetLayerBounds(const Tizen::Graphics::FloatRectangle& bounds);
 
 #if defined(MULTI_WINDOW)
        virtual result CreateLayer(void);
@@ -86,7 +86,7 @@ private:
 #endif // !MULTI_WINDOW
        Tizen::Ui::Animations::_RootVisualElement* __pLiveboxFrameRootVisualElement;
        Tizen::Ui::_IUiEventManager* __pEventManager;
-       Tizen::Graphics::Dimension __liveboxSize;
+       Tizen::Graphics::FloatDimension __liveboxSize;
 }; // _LiveboxFrame
 
 }} // Tizen::Shell

diff --git a/src/FShell_LiveboxFrameImpl.cpp b/src/FShell_LiveboxFrameImpl.cpp
index 66bcd76..8be0637 100644 (file)
--- a/src/FShell_LiveboxFrameImpl.cpp
+++ b/src/FShell_LiveboxFrameImpl.cpp
@@ -98,7 +98,7 @@ _LiveboxFrameImpl::GetCore(void)
 }
 
 result
-_LiveboxFrameImpl::Initialize(const Dimension& size)
+_LiveboxFrameImpl::Initialize(const FloatDimension& size)
 {
        result r = GetCore().Initialize(size);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));

diff --git a/src/FShell_LiveboxFrameImpl.h b/src/FShell_LiveboxFrameImpl.h
index 5605262..98ba66c 100644 (file)
--- a/src/FShell_LiveboxFrameImpl.h
+++ b/src/FShell_LiveboxFrameImpl.h
@@ -45,7 +45,7 @@ public:
        virtual const _LiveboxFrame& GetCore(void) const;
        virtual _LiveboxFrame& GetCore(void);
 
-       result Initialize(const Tizen::Graphics::Dimension& size);
+       result Initialize(const Tizen::Graphics::FloatDimension& size);
        result SetProviderId(const Tizen::Base::String& providerId);
 
 protected:

diff --git a/src/FShell_LiveboxLayer.cpp b/src/FShell_LiveboxLayer.cpp
index cb2fe03..dbcf29a 100644 (file)
--- a/src/FShell_LiveboxLayer.cpp
+++ b/src/FShell_LiveboxLayer.cpp
@@ -79,7 +79,7 @@ PostRender(void* pData, Evas* pEvas, void* pEventInfo)
 namespace Tizen { namespace Shell
 {
 
-_LiveboxLayer::_LiveboxLayer(const Dimension& size)
+_LiveboxLayer::_LiveboxLayer(const FloatDimension& size)
        : __isReleased(false)
        , __size(size)
        , __pEcoreEvas(null)
@@ -162,14 +162,14 @@ _LiveboxLayer::GetPixmapId(void) const
 }
 
 void
-_LiveboxLayer::SetLayerBounds(const Rectangle& bounds)
+_LiveboxLayer::SetLayerBounds(const FloatRectangle& bounds)
 {
-       __size = Dimension(bounds.width, bounds.height);
+       __size = FloatDimension(bounds.width, bounds.height);
 
        ecore_evas_resize(__pEcoreEvas.get(), __size.width, __size.height);
 
-       FloatRectangle fBounds(static_cast<float>(bounds.x), static_cast<float>(bounds.y), static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-       SetBounds(fBounds);
+//     FloatRectangle fBounds(static_cast<float>(bounds.x), static_cast<float>(bounds.y), static_cast<float>(bounds.width), static_cast<float>(bounds.height));
+       SetBounds(bounds);
 }
 
 void*
@@ -209,7 +209,7 @@ _LiveboxLayer::FreeCanvas(void* pCanvas)
 }
 
 result
-_LiveboxLayer::SyncPixmap(const Dimension& size)
+_LiveboxLayer::SyncPixmap(const FloatDimension& size)
 {
        SysTryReturn(NID_UI_CTRL, __pRenderBuffer, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 
@@ -337,7 +337,7 @@ _LiveboxLayer::AcquirePixmap(void)
 }
 
 result
-_LiveboxLayer::Sync(const Dimension& size)
+_LiveboxLayer::Sync(const FloatDimension& size)
 {
        SysTryReturn(NID_UI_CTRL, !__providerId.IsEmpty(), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 

diff --git a/src/FShell_LiveboxLayer.h b/src/FShell_LiveboxLayer.h
index 264ad01..fb4640c 100644 (file)
--- a/src/FShell_LiveboxLayer.h
+++ b/src/FShell_LiveboxLayer.h
@@ -47,7 +47,7 @@ class _LiveboxLayer
        , public Tizen::Shell::_ILiveboxTouchEventListener
 {
 public:
-       _LiveboxLayer(const Tizen::Graphics::Dimension& size);
+       _LiveboxLayer(const Tizen::Graphics::FloatDimension& size);
        virtual ~_LiveboxLayer(void);
 
        virtual result OnConstructed(void);
@@ -55,16 +55,16 @@ public:
        result SetProviderId(const Tizen::Base::String& providerId);
        Tizen::Base::String GetProviderId(void) const;
        int GetPixmapId(void) const;
-       void SetLayerBounds(const Tizen::Graphics::Rectangle& bounds);
+       void SetLayerBounds(const Tizen::Graphics::FloatRectangle& bounds);
        void* AllocCanvas(int size);
        void FreeCanvas(void* pCanvas);
        int EventHandler(int eventType, double timestamp, double x, double y);
-       result SyncPixmap(const Tizen::Graphics::Dimension& size);
+       result SyncPixmap(const Tizen::Graphics::FloatDimension& size);
        void OnRendered(void);
 
        virtual result RegisterTouchEventListener(void);
        virtual int AcquirePixmap(void);
-       virtual result Sync(const Tizen::Graphics::Dimension& size);
+       virtual result Sync(const Tizen::Graphics::FloatDimension& size);
        virtual void ReleasePixmap(void);
        virtual int OnTouchEventRecevied(int eventType, double timestamp, double x, double y);
 
@@ -74,7 +74,7 @@ private:
 
 protected:
        bool __isReleased;
-       Tizen::Graphics::Dimension __size;
+       Tizen::Graphics::FloatDimension __size;
 
 private:
        struct _EcoreEvasDeleter

diff --git a/src/FShell_LiveboxPopup.cpp b/src/FShell_LiveboxPopup.cpp
index b97e6d1..52b5ade 100644 (file)
--- a/src/FShell_LiveboxPopup.cpp
+++ b/src/FShell_LiveboxPopup.cpp
@@ -53,7 +53,7 @@ class _LiveboxPopupLayer
        : public _LiveboxLayer
 {
 public:
-       _LiveboxPopupLayer(const Dimension& size);
+       _LiveboxPopupLayer(const FloatDimension& size);
        virtual ~_LiveboxPopupLayer(void);
 
 private:
@@ -62,11 +62,11 @@ private:
 
        virtual result RegisterTouchEventListener(void);
        virtual int AcquirePixmap(void);
-       virtual result Sync(const Dimension& size);
+       virtual result Sync(const FloatDimension& size);
        virtual void ReleasePixmap(void);
 };
 
-_LiveboxPopupLayer::_LiveboxPopupLayer(const Dimension& size)
+_LiveboxPopupLayer::_LiveboxPopupLayer(const FloatDimension& size)
        : _LiveboxLayer(size)
 {
 }
@@ -110,7 +110,7 @@ _LiveboxPopupLayer::AcquirePixmap(void)
 }
 
 result
-_LiveboxPopupLayer::Sync(const Dimension& size)
+_LiveboxPopupLayer::Sync(const FloatDimension& size)
 {
        result r = _LiveboxProviderManagerImpl::GetInstance()->RequestSyncSharedMemoryForPD(GetProviderId());
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
@@ -180,7 +180,7 @@ _LiveboxPopup::CreateLiveboxPopupN(void)
 }
 
 result
-_LiveboxPopup::Initialize(const Dimension& size)
+_LiveboxPopup::Initialize(const FloatDimension& size)
 {
        long long ticks = 0;
        SystemTime::GetTicks(ticks);
@@ -217,8 +217,8 @@ _LiveboxPopup::Initialize(const Dimension& size)
        __pLiveboxPopupRootVisualElement->AttachChild(*pVisualElement);
 #endif // MULTI_WINDOW
 
-       Rectangle bounds(0, 0, size.width, size.height);
-       r = SetBounds(bounds);
+       FloatRectangle bounds(0.0f, 0.0f, size.width, size.height);
+       r = SetBoundsF(bounds);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
        r = __pLiveboxPopupPresenter->Initialize();
@@ -227,11 +227,9 @@ _LiveboxPopup::Initialize(const Dimension& size)
        __pLiveboxPopupLayer->SetLayerBounds(bounds);
        __pLiveboxPopupLayer->SetShowState(false);
 
-       FloatRectangle fBounds(0.0f, 0.0f, static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-
        __pLiveboxPopupRootVisualElement->SetImplicitAnimationEnabled(false);
        __pLiveboxPopupRootVisualElement->SetName(L"_LiveboxPopup");
-       __pLiveboxPopupRootVisualElement->SetBounds(fBounds);
+       __pLiveboxPopupRootVisualElement->SetBounds(bounds);
        __pLiveboxPopupRootVisualElement->SetShowState(false);
 
        SetBackgroundColor(Color(0, 0, 0, 0));
@@ -261,7 +259,7 @@ _LiveboxPopup::GetProviderId(void) const
 }
 
 void
-_LiveboxPopup::SetAnchorPosition(const Tizen::Graphics::FloatPoint& position)
+_LiveboxPopup::SetAnchorPosition(const FloatPoint& position)
 {
        return __pLiveboxPopupPresenter->SetAnchorPosition(position);
 }
@@ -272,27 +270,30 @@ _LiveboxPopup::GetAnchorPosition(void) const
        return __pLiveboxPopupPresenter->GetAnchorPosition();
 }
 
-Rectangle
-_LiveboxPopup::GetLiveboxPopupClientBounds(void) const
+Canvas*\r
+_LiveboxPopup::GetClientAreaCanvasN(void) const\r
+{\r
+       Canvas* pCanvas = GetCanvasFN(GetClientBoundsF());
+       result r = GetLastResult();
+       SysTryReturn(NID_UI_CTRL, pCanvas, null, r, "[%s] Propagating.", GetErrorMessage(r));
+
+       return pCanvas;\r
+}\r
+\r
+FloatPoint\r
+_LiveboxPopup::TranslateToClientAreaPosition(const FloatPoint& position) const\r
+{\r
+       FloatRectangle leftTop = GetClientBoundsF();
+
+       return FloatPoint(position.x - leftTop.x, position.y - leftTop.y);\r
+}\r
+\r
+FloatPoint
+_LiveboxPopup::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
 {
-       int leftMargin = 0;
-       int rightMargin = 0;
-       int topMargin = 0;
-       int bottomMargin = 0;
-       _ControlOrientation orientation = GetOrientation();
+       FloatRectangle leftTop = GetClientBoundsF();
 
-       GET_SHAPE_CONFIG(LIVEBOX::POPUP_LEFT_MARGIN, orientation, leftMargin);
-       GET_SHAPE_CONFIG(LIVEBOX::POPUP_RIGHT_MARGIN, orientation, rightMargin);
-       GET_SHAPE_CONFIG(LIVEBOX::POPUP_TOP_MARGIN, orientation, topMargin);
-       GET_SHAPE_CONFIG(LIVEBOX::POPUP_BOTTOM_MARGIN, orientation, bottomMargin);
-
-       Rectangle bounds = GetBounds();
-
-       Rectangle clientBounds(bounds.x + leftMargin, bounds.y + topMargin, bounds.width - leftMargin - rightMargin, bounds.height - topMargin - bottomMargin);
-
-       SysLog(NID_UI_CTRL, "[%d %d %d %d]", clientBounds.x, clientBounds.y, clientBounds.width, clientBounds.height);
-
-       return clientBounds;
+       return FloatPoint(clientPosition.x + leftTop.x, clientPosition.y + leftTop.y);
 }
 
 result
@@ -315,7 +316,7 @@ _LiveboxPopup::SetLayerShowState(bool showState)
 }
 
 result
-_LiveboxPopup::SetLayerBounds(const Rectangle& bounds)
+_LiveboxPopup::SetLayerBounds(const FloatRectangle& bounds)
 {
        result r = E_SUCCESS;
 
@@ -326,14 +327,35 @@ _LiveboxPopup::SetLayerBounds(const Rectangle& bounds)
                SysTryReturn(NID_UI_CTRL, pLayer, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
                pLayer->SetLayerBounds(bounds);
-
-               FloatRectangle fBounds(0.0f, 0.0f, static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-               __pLiveboxPopupRootVisualElement->SetBounds(fBounds);
+               __pLiveboxPopupRootVisualElement->SetBounds(bounds);
        }
 
        return r;
 }
 
+FloatRectangle
+_LiveboxPopup::GetLiveboxPopupClientBounds(void) const
+{
+       int leftMargin = 0;
+       int rightMargin = 0;
+       int topMargin = 0;
+       int bottomMargin = 0;
+       _ControlOrientation orientation = GetOrientation();
+
+       GET_SHAPE_CONFIG(LIVEBOX::POPUP_LEFT_MARGIN, orientation, leftMargin);
+       GET_SHAPE_CONFIG(LIVEBOX::POPUP_RIGHT_MARGIN, orientation, rightMargin);
+       GET_SHAPE_CONFIG(LIVEBOX::POPUP_TOP_MARGIN, orientation, topMargin);
+       GET_SHAPE_CONFIG(LIVEBOX::POPUP_BOTTOM_MARGIN, orientation, bottomMargin);
+
+       FloatRectangle bounds = GetBoundsF();
+
+       FloatRectangle clientBounds(bounds.x + leftMargin, bounds.y + topMargin, bounds.width - leftMargin - rightMargin, bounds.height - topMargin - bottomMargin);
+
+       SysLog(NID_UI_CTRL, "[%d %d %d %d]", clientBounds.x, clientBounds.y, clientBounds.width, clientBounds.height);
+
+       return clientBounds;
+}
+
 #if defined(MULTI_WINDOW)
 result
 _LiveboxPopup::CreateLayer(void)
@@ -364,11 +386,9 @@ _LiveboxPopup::OnActivated(void)
 void
 _LiveboxPopup::OnBoundsChanged(void)
 {
-       Rectangle bounds = GetBounds();
-
-       SetLayerBounds(bounds);
+       SetLayerBounds(GetBoundsF());
 
-       SetClientBounds(GetLiveboxPopupClientBounds());
+       SetClientBoundsF(GetLiveboxPopupClientBounds());
 }
 
 void

diff --git a/src/FShell_LiveboxPopup.h b/src/FShell_LiveboxPopup.h
index b346fec..d2a2a5b 100644 (file)
--- a/src/FShell_LiveboxPopup.h
+++ b/src/FShell_LiveboxPopup.h
@@ -30,6 +30,7 @@
 namespace Tizen { namespace Graphics
 {
 class Dimension;
+class FloatDimension;
 class FloatPoint;
 }} // Tizen::Graphics
 
@@ -61,12 +62,14 @@ public:
        static _LiveboxPopup* CreateLiveboxPopupN(void);
        virtual ~_LiveboxPopup(void);
 
-       result Initialize(const Tizen::Graphics::Dimension& size);
+       result Initialize(const Tizen::Graphics::FloatDimension& size);
        result SetProviderId(const Tizen::Base::String& providerId);
        Tizen::Base::String GetProviderId(void) const;
        void SetAnchorPosition(const Tizen::Graphics::FloatPoint& position);
        Tizen::Graphics::FloatPoint GetAnchorPosition(void) const;
-       Tizen::Graphics::Rectangle GetLiveboxPopupClientBounds(void) const;
+       Tizen::Graphics::Canvas* GetClientAreaCanvasN(void) const;\r
+       Tizen::Graphics::FloatPoint TranslateToClientAreaPosition(const Tizen::Graphics::FloatPoint& position) const;\r
+       Tizen::Graphics::FloatPoint TranslateFromClientAreaPosition(const Tizen::Graphics::FloatPoint& clientPosition) const;
 
 protected:
        _LiveboxPopup(void);
@@ -76,7 +79,8 @@ private:
        _LiveboxPopup& operator =(const _LiveboxPopup&  rhs);
 
        result SetLayerShowState(bool showState);
-       result SetLayerBounds(const Tizen::Graphics::Rectangle& bounds);
+       result SetLayerBounds(const Tizen::Graphics::FloatRectangle& bounds);
+       Tizen::Graphics::FloatRectangle GetLiveboxPopupClientBounds(void) const;
 
 #if defined(MULTI_WINDOW)
        virtual result CreateLayer(void);
@@ -94,7 +98,7 @@ private:
 #endif // !MULTI_WINDOW
        Tizen::Ui::Animations::_RootVisualElement* __pLiveboxPopupRootVisualElement;
        Tizen::Ui::_IUiEventManager* __pEventManager;
-       Tizen::Graphics::Dimension __liveboxSize;
+       Tizen::Graphics::FloatDimension __liveboxSize;
 }; // _LiveboxPopup
 
 }} // Tizen::Shell

diff --git a/src/FShell_LiveboxPopupImpl.cpp b/src/FShell_LiveboxPopupImpl.cpp
index c1c0e1f..f1f01da 100644 (file)
--- a/src/FShell_LiveboxPopupImpl.cpp
+++ b/src/FShell_LiveboxPopupImpl.cpp
@@ -98,7 +98,7 @@ _LiveboxPopupImpl::GetCore(void)
 }
 
 result
-_LiveboxPopupImpl::Initialize(const Dimension& size)
+_LiveboxPopupImpl::Initialize(const FloatDimension& size)
 {
        result r = GetCore().Initialize(size);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
@@ -122,7 +122,7 @@ _LiveboxPopupImpl::GetProviderId(void) const
 }
 
 void
-_LiveboxPopupImpl::SetAnchorPosition(const Tizen::Graphics::FloatPoint& position)
+_LiveboxPopupImpl::SetAnchorPosition(const FloatPoint& position)
 {
        GetCore().SetAnchorPosition(position);
 }
@@ -133,4 +133,28 @@ _LiveboxPopupImpl::GetAnchorPosition(void) const
        return GetCore().GetAnchorPosition();
 }
 
+FloatRectangle\r
+_LiveboxPopupImpl::GetClientAreaBounds(void) const\r
+{\r
+       return GetClientBoundsF();\r
+}\r
+\r
+Canvas*\r
+_LiveboxPopupImpl::GetClientAreaCanvasN(void) const\r
+{\r
+       return GetCore().GetClientAreaCanvasN();\r
+}\r
+\r
+FloatPoint\r
+_LiveboxPopupImpl::TranslateToClientAreaPosition(const FloatPoint& position) const\r
+{\r
+       return GetCore().TranslateToClientAreaPosition(position);\r
+}\r
+\r
+FloatPoint
+_LiveboxPopupImpl::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
+{
+       return GetCore().TranslateFromClientAreaPosition(clientPosition);
+}
+
 }} // Tizen::Shell

diff --git a/src/FShell_LiveboxPopupImpl.h b/src/FShell_LiveboxPopupImpl.h
index 047f842..81b4613 100644 (file)
--- a/src/FShell_LiveboxPopupImpl.h
+++ b/src/FShell_LiveboxPopupImpl.h
@@ -24,6 +24,7 @@
 namespace Tizen { namespace Graphics
 {
 class Dimension;
+class FloatDimension;
 class FloatPoint;
 }} // Tizen::Graphics
 
@@ -46,11 +47,15 @@ public:
        virtual const _LiveboxPopup& GetCore(void) const;
        virtual _LiveboxPopup& GetCore(void);
 
-       result Initialize(const Tizen::Graphics::Dimension& size);
+       result Initialize(const Tizen::Graphics::FloatDimension& size);
        result SetProviderId(const Tizen::Base::String& providerId);
        Tizen::Base::String GetProviderId(void) const;
        void SetAnchorPosition(const Tizen::Graphics::FloatPoint& position);
-       Tizen::Graphics::FloatPoint GetAnchorPosition(void) const;
+       Tizen::Graphics::FloatPoint GetAnchorPosition(void) const;\r
+       Tizen::Graphics::FloatRectangle GetClientAreaBounds(void) const;\r
+       Tizen::Graphics::Canvas* GetClientAreaCanvasN(void) const;\r
+       Tizen::Graphics::FloatPoint TranslateToClientAreaPosition(const Tizen::Graphics::FloatPoint& position) const;\r
+       Tizen::Graphics::FloatPoint TranslateFromClientAreaPosition(const Tizen::Graphics::FloatPoint& clientPosition) const;
 
 protected:
        _LiveboxPopupImpl(LiveboxPopup* pPublic, _LiveboxPopup* pCore, const Tizen::Ui::Layout* pPortraitLayout, const Tizen::Ui::Layout* pLandscapeLayout);

diff --git a/src/FShell_LiveboxPopupView.cpp b/src/FShell_LiveboxPopupView.cpp
index 4aa3f7d..7664183 100644 (file)
--- a/src/FShell_LiveboxPopupView.cpp
+++ b/src/FShell_LiveboxPopupView.cpp
@@ -105,11 +105,11 @@ _LiveboxPopupView::CreateLiveboxPopupN(_LiveboxView& liveBoxView)
 }
 
 result
-_LiveboxPopupView::Initialize(const Rectangle& bounds)
+_LiveboxPopupView::Initialize(const FloatRectangle& bounds)
 {
-       Dimension screenSize = _ControlManager::GetInstance()->GetScreenSize();
+       FloatDimension screenSize = _ControlManager::GetInstance()->GetScreenSizeF();
 
-       Rectangle viewAbsoluteBounds = __pLiveboxView->GetAbsoluteBounds();
+       FloatRectangle viewAbsoluteBounds = __pLiveboxView->GetAbsoluteBoundsF();
        double x = (static_cast<double>(viewAbsoluteBounds.x) + static_cast<double>((viewAbsoluteBounds.width) / 2)) / static_cast<double>(screenSize.width);
        double y = 0.0f;
 
@@ -129,7 +129,7 @@ _LiveboxPopupView::Initialize(const Rectangle& bounds)
        int ret = livebox_create_pd_with_position(__pLiveboxView->__pLivebox, x, y, OnLiveboxPopupCreated, this);
        SysTryReturn(NID_UI_CTRL, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 
-       result r = SetBounds(bounds);
+       result r = SetBoundsF(bounds);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
        return r;
@@ -160,15 +160,15 @@ _LiveboxPopupView::GetBitmap(void) const
 }
 
 void
-_LiveboxPopupView::SetPopupBounds(const Dimension& size)
+_LiveboxPopupView::SetPopupBounds(const FloatDimension& size)
 {
-       Rectangle absoluteViewBounds = __pLiveboxView->GetAbsoluteBounds();
-       Rectangle popupBounds(0, 0, size.width, size.height);
+       FloatRectangle absoluteViewBounds = __pLiveboxView->GetAbsoluteBoundsF();
+       FloatRectangle popupBounds(0, 0, size.width, size.height);
 
        int lower = 0;
        int upper = 0;
 
-       Dimension anchorSize = __pLiveboxView->GetAnchorSize();
+       FloatDimension anchorSize = __pLiveboxView->GetAnchorSize();
        __pLiveboxView->GetRemainingSpace(lower, upper);
 
        if (lower > upper)
@@ -180,7 +180,7 @@ _LiveboxPopupView::SetPopupBounds(const Dimension& size)
                popupBounds.y = absoluteViewBounds.y + absoluteViewBounds.height - anchorSize.height;
        }
 
-       SetBounds(popupBounds);
+       SetBoundsF(popupBounds);
 
        SysLog(NID_UI_CTRL, "[%d %d %d %d]", popupBounds.x, popupBounds.y, popupBounds.width, popupBounds.height);
 }
@@ -199,9 +199,9 @@ _LiveboxPopupView::FireLiveboxPopupEvent(bool open)
 }
 
 void
-_LiveboxPopupView::GetTouchPostion(const Tizen::Graphics::Point& point, double& x, double& y) const
+_LiveboxPopupView::GetTouchPostion(const Tizen::Graphics::FloatPoint& point, double& x, double& y) const
 {
-       Rectangle bounds = GetBounds();
+       FloatRectangle bounds = GetBoundsF();
 
        x = static_cast<double>(point.x) / static_cast<double>(bounds.width);
        y = static_cast<double>(point.y) / static_cast<double>(bounds.height);
@@ -220,14 +220,13 @@ _LiveboxPopupView::PlayAnimation(bool open)
        VisualElementAnimationGroup animationGroup;
        animationGroup.SetVisualElementAnimationStatusEventListener(this);
 
-       Rectangle bounds = GetBounds();
-       FloatRectangle boundsf(0.0f, 0.0f, static_cast<float>(bounds.width), static_cast<float>(bounds.height));
-       FloatRectangle startBounds(0.0f, boundsf.y, boundsf.width, 0.0f);
-       FloatRectangle endBounds(boundsf);
+       FloatRectangle bounds = GetBoundsF();
+       FloatRectangle startBounds(0.0f, bounds.y, bounds.width, 0.0f);
+       FloatRectangle endBounds(bounds);
        if (!open)
        {
-               startBounds = boundsf;
-               endBounds = FloatRectangle(0.0f, boundsf.y, boundsf.width, 0.0f);
+               startBounds = bounds;
+               endBounds = FloatRectangle(0.0f, bounds.y, bounds.width, 0.0f);
        }
 
        VisualElementPropertyAnimation animation1;
@@ -302,10 +301,11 @@ _LiveboxPopupView::OnDeactivated(void)
 bool
 _LiveboxPopupView::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo)
 {
-       double x = 0.0f;
-       double y = 0.0f;
+       double x = 0.0;
+       double y = 0.0;
 
-       GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+       Point position = touchInfo.GetCurrentPosition();
+       GetTouchPostion(FloatPoint(static_cast<float>(position.x), static_cast<float>(position.y)), x, y);
 
        livebox_content_event(__pLiveboxView->__pLivebox, PD_MOUSE_DOWN, x, y);
 
@@ -315,18 +315,20 @@ _LiveboxPopupView::OnTouchPressed(const _Control& source, const _TouchInfo& touc
 bool
 _LiveboxPopupView::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 {
-       Rectangle clientBounds(GetClientBounds());
-       Point touchPoint(touchInfo.GetCurrentPosition());
+       FloatRectangle clientBounds(GetClientBoundsF());
+
+       Point position = touchInfo.GetCurrentPosition();
+       FloatPoint floatPosition(static_cast<float>(position.x), static_cast<float>(position.y));
 
-       if (!clientBounds.Contains(touchPoint))
+       if (!clientBounds.Contains(floatPosition))
        {
                PlayAnimation(false);
        }
 
-       double x = 0.0f;
-       double y = 0.0f;
+       double x = 0.0;
+       double y = 0.0;
 
-       GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+       GetTouchPostion(floatPosition, x, y);
 
        livebox_content_event(__pLiveboxView->__pLivebox, PD_MOUSE_UP, x, y);
 
@@ -336,10 +338,11 @@ _LiveboxPopupView::OnTouchReleased(const _Control& source, const _TouchInfo& tou
 bool
 _LiveboxPopupView::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
 {
-       double x = 0.0f;
-       double y = 0.0f;
+       double x = 0.0;
+       double y = 0.0;
 
-       GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+       Point position = touchInfo.GetCurrentPosition();
+       GetTouchPostion(FloatPoint(static_cast<float>(position.x), static_cast<float>(position.y)), x, y);
 
        livebox_content_event(__pLiveboxView->__pLivebox, PD_MOUSE_MOVE, x, y);
 
@@ -379,14 +382,14 @@ _LiveboxPopupView::OnDraw(void)
 }
 
 void
-_LiveboxPopupView::OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::Dimension& size)
+_LiveboxPopupView::OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::FloatDimension& size)
 {
        long long ticks = 0;
        SystemTime::GetTicks(ticks);
 
        SysLog(NID_UI_CTRL, "(%d %d) %lld", size.width, size.height, ticks);
 
-       if (size != GetSize())
+       if (size != GetSizeF())
        {
                SetPopupBounds(size);
        }
@@ -470,8 +473,8 @@ _LiveboxPopupView::OnLiveboxUpdated(int pixmap)
        evas_object_image_data_update_add(__pPixmapObject.get(), 0, 0, width, height);
        evas_object_resize(__pPixmapObject.get(), width, height);
 
-       Dimension size(width, height);
-       if (size != GetSize())
+       FloatDimension size(width, height);
+       if (size != GetSizeF())
        {
                SetPopupBounds(size);
        }

diff --git a/src/FShell_LiveboxPopupView.h b/src/FShell_LiveboxPopupView.h
index 6ccaba2..306a1a0 100644 (file)
--- a/src/FShell_LiveboxPopupView.h
+++ b/src/FShell_LiveboxPopupView.h
@@ -38,8 +38,8 @@ class String;
 namespace Tizen { namespace Graphics
 {
 class Bitmap;
-class Dimension;
-class Point;
+class FloatDimension;
+class FloatPoint;
 }} // Tizen::Graphics
 
 namespace Tizen { namespace Ui { namespace Animations
@@ -69,7 +69,7 @@ public:
        static _LiveboxPopupView* CreateLiveboxPopupN(_LiveboxView& liveBoxView);
        virtual ~_LiveboxPopupView(void);
 
-       result Initialize(const Tizen::Graphics::Rectangle& bounds);
+       result Initialize(const Tizen::Graphics::FloatRectangle& bounds);
        result AddLiveboxPopupEventListener(const _ILiveboxPopupViewEventListener& listener);
        result RemoveLiveboxPopupEventListener(const _ILiveboxPopupViewEventListener& listener);
        Tizen::Graphics::Bitmap* GetBitmap(void) const;
@@ -81,9 +81,9 @@ private:
        _LiveboxPopupView(const _LiveboxPopupView& rhs);
        _LiveboxPopupView& operator =(const _LiveboxPopupView&  rhs);
 
-       void SetPopupBounds(const Tizen::Graphics::Dimension& size);
+       void SetPopupBounds(const Tizen::Graphics::FloatDimension& size);
        void FireLiveboxPopupEvent(bool open);
-       void GetTouchPostion(const Tizen::Graphics::Point& point, double& x, double& y) const;
+       void GetTouchPostion(const Tizen::Graphics::FloatPoint& point, double& x, double& y) const;
        void PlayAnimation(bool open);
 
        virtual result OnAttached(void);
@@ -98,7 +98,7 @@ private:
        virtual void OnVisualElementAnimationRepeated(const Tizen::Ui::Animations::VisualElementAnimation& animation, const Tizen::Base::String& keyName, Tizen::Ui::Animations::VisualElement& target, long currentRepeatCount);
        virtual void OnDraw(void);
 
-       void OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::Dimension& size);
+       void OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::FloatDimension& size);
        void OnLiveboxUpdated(int pixmap);
 
        static void OnLiveboxPopupCreated(struct livebox *pLivebox, int ret, void* pData);

diff --git a/src/FShell_LiveboxView.cpp b/src/FShell_LiveboxView.cpp
index 2c0c84b..80bcb38 100644 (file)
--- a/src/FShell_LiveboxView.cpp
+++ b/src/FShell_LiveboxView.cpp
@@ -99,14 +99,14 @@ _LiveboxView::CreateLiveboxViewN(void)
 }
 
 result
-_LiveboxView::Initialize(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const String& userInfo)
+_LiveboxView::Initialize(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect, const String& userInfo)
 {
        SysLog(NID_UI_CTRL, "appId [%ls]", appId.GetPointer());
        SysLog(NID_UI_CTRL, "providerName [%ls]", providerName.GetPointer());
        SysLog(NID_UI_CTRL, "[%d %d %d %d]", rect.x, rect.y, rect.width, rect.height);
        SysLog(NID_UI_CTRL, "userInfo [%ls]", userInfo.GetPointer());
 
-       result r = SetBounds(rect);
+       result r = SetBoundsF(rect);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
        r = __pLiveboxViewPresenter->Initialize(appId, providerName);
@@ -190,7 +190,7 @@ _LiveboxView::IsUpdated(void) const
        return __updated;
 }
 
-Dimension
+FloatDimension
 _LiveboxView::GetAnchorSize(void) const
 {
        Bitmap* pArrowBitmap = null;
@@ -208,7 +208,7 @@ _LiveboxView::GetAnchorSize(void) const
                pArrowBitmap = __pArrowUpBitmap.get();
        }
 
-       return Dimension(pArrowBitmap->GetWidth(), pArrowBitmap->GetHeight());
+       return FloatDimension(pArrowBitmap->GetWidth(), pArrowBitmap->GetHeight());
 }
 
 livebox*
@@ -226,15 +226,15 @@ _LiveboxView::OpenLiveboxPopup(void)
        r = GetLastResult();
        SysTryReturn(NID_UI_CTRL, pParent, r, r, "[%s] Propagating.", GetErrorMessage(r));
 
-       Dimension size = __pLiveboxViewManager->GetLiveboxPopupSize(__pLivebox);
-       Rectangle popupBounds(0, 0, size.width, size.height);
-       Rectangle bounds = GetBounds();
-       Rectangle absoluteBounds = GetAbsoluteBounds();
+       FloatDimension size = __pLiveboxViewManager->GetLiveboxPopupSize(__pLivebox);
+       FloatRectangle popupBounds(0, 0, size.width, size.height);
+       FloatRectangle bounds = GetBoundsF();
+       FloatRectangle absoluteBounds = GetAbsoluteBoundsF();
 
        int lower = 0;
        int upper = 0;
 
-       Dimension anchorSize = GetAnchorSize();
+       FloatDimension anchorSize = GetAnchorSize();
        GetRemainingSpace(lower, upper);
 
        if (lower > upper)
@@ -272,9 +272,9 @@ _LiveboxView::OpenLiveboxPopup(void)
 }
 
 void
-_LiveboxView::GetTouchPostion(const Point& point, double& x, double& y) const
+_LiveboxView::GetTouchPostion(const FloatPoint& point, double& x, double& y) const
 {
-       Rectangle bounds = GetBounds();
+       FloatRectangle bounds = GetBoundsF();
 
        x = static_cast<double>(point.x) / static_cast<double>(bounds.width);
        y = static_cast<double>(point.y) / static_cast<double>(bounds.height);
@@ -326,8 +326,8 @@ _LiveboxView::GetRemainingSpace(int& lower, int& upper) const
        result r = GetLastResult();
        SysTryReturnVoidResult(NID_UI_CTRL, pParent, r, "[%s] Propagating.", GetErrorMessage(r));
 
-       Rectangle parentClientBounds = pParent->GetClientBounds();
-       Rectangle viewBounds = GetBounds();
+       FloatRectangle parentClientBounds = pParent->GetClientBoundsF();
+       FloatRectangle viewBounds = GetBoundsF();
 
        lower = viewBounds.y;
        upper = parentClientBounds.height - viewBounds.y - viewBounds.height;
@@ -373,7 +373,7 @@ _LiveboxView::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 void
 _LiveboxView::OnBoundsChanged(void)
 {
-       Dimension size(GetSize());
+       FloatDimension size(GetSizeF());
 
        if (!__resizeFromRemote)
        {
@@ -388,9 +388,11 @@ _LiveboxView::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo
        int type = livebox_lb_type(__pLivebox);
        if ((type == LB_TYPE_BUFFER) || (type == LB_TYPE_PIXMAP))
        {
-               double x = 0.0f;
-               double y = 0.0f;
-               GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+               double x = 0.0;
+               double y = 0.0;
+
+               Point position = touchInfo.GetCurrentPosition();
+               GetTouchPostion(FloatPoint(static_cast<float>(position.x), static_cast<float>(position.y)), x, y);
 
                livebox_content_event(__pLivebox, LB_MOUSE_DOWN, x, y);
        }
@@ -401,17 +403,18 @@ _LiveboxView::OnTouchPressed(const _Control& source, const _TouchInfo& touchInfo
 bool
 _LiveboxView::OnTouchReleased(const _Control& source, const _TouchInfo& touchInfo)
 {
-       Rectangle clientBounds(GetClientBounds());
-       Point touchPoint(touchInfo.GetCurrentPosition());
+       FloatRectangle clientBounds(GetClientBoundsF());
+       Point position(touchInfo.GetCurrentPosition());
+       FloatPoint floatPosition(static_cast<float>(position.x), static_cast<float>(position.y));
 
-       if (clientBounds.Contains(touchPoint))
+       if (clientBounds.Contains(floatPosition))
        {
                PlayClickAnimation();
        }
 
-       double x = 0.0f;
-       double y = 0.0f;
-       GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+       double x = 0.0;
+       double y = 0.0;
+       GetTouchPostion(floatPosition, x, y);
 
        int type = livebox_lb_type(__pLivebox);
        if ((type == LB_TYPE_BUFFER) || (type == LB_TYPE_PIXMAP))
@@ -430,9 +433,11 @@ _LiveboxView::OnTouchMoved(const _Control& source, const _TouchInfo& touchInfo)
        int type = livebox_lb_type(__pLivebox);
        if ((type == LB_TYPE_BUFFER) || (type == LB_TYPE_PIXMAP))
        {
-               double x = 0.0f;
-               double y = 0.0f;
-               GetTouchPostion(touchInfo.GetCurrentPosition(), x, y);
+               double x = 0.0;
+               double y = 0.0;
+
+               Point position = touchInfo.GetCurrentPosition();
+               GetTouchPostion(FloatPoint(static_cast<float>(position.x), static_cast<float>(position.y)), x, y);
 
                livebox_content_event(__pLivebox, LB_MOUSE_MOVE, x, y);
        }
@@ -458,10 +463,10 @@ _LiveboxView::OnDraw(void)
 }
 
 void
-_LiveboxView::OnLiveboxUpdated(const Bitmap& bitmap, const Dimension& size)
+_LiveboxView::OnLiveboxUpdated(const Bitmap& bitmap, const FloatDimension& size)
 {
        __resizeFromRemote = true;
-       SetSize(size);
+       SetSizeF(size);
        __resizeFromRemote = false;
        __updated = true;
 
@@ -507,7 +512,7 @@ _LiveboxView::OnLiveboxUpdated(int pixmap)
                evas_object_image_alpha_set(__pPixmapObject.get(), EINA_TRUE);
                evas_object_raise(__pPixmapObject.get());
 
-               Rectangle absoluteBounds = GetAbsoluteBounds();
+               FloatRectangle absoluteBounds = GetAbsoluteBoundsF();
 
                evas_object_move(__pPixmapObject.get(), absoluteBounds.x, absoluteBounds.y);
                evas_object_show(__pPixmapObject.get());
@@ -539,7 +544,7 @@ _LiveboxView::OnLiveboxUpdated(int pixmap)
        evas_object_resize(__pPixmapObject.get(), width, height);
 
        __resizeFromRemote = true;
-       SetSize(Dimension(width, height));
+       SetSizeF(FloatDimension(static_cast<float>(width), static_cast<float>(height)));
        __resizeFromRemote = false;
        __updated = true;
 

diff --git a/src/FShell_LiveboxView.h b/src/FShell_LiveboxView.h
index 0ba02e7..baf8332 100644 (file)
--- a/src/FShell_LiveboxView.h
+++ b/src/FShell_LiveboxView.h
@@ -41,7 +41,7 @@ class String;
 namespace Tizen { namespace Graphics
 {
 class Bitmap;
-class Dimension;
+class FloatDimension;
 class Point;
 }} // Tizen::Graphics
 
@@ -70,14 +70,14 @@ public:
        static _LiveboxView* CreateLiveboxViewN(void);
        virtual ~_LiveboxView(void);
 
-       result Initialize(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const Tizen::Base::String& userInfo);
+       result Initialize(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect, const Tizen::Base::String& userInfo);
        _LiveboxPopupView* GetLiveboxPopup(void) const;
        Tizen::Base::String GetAppId(void) const;
        Tizen::Base::String GetLiveboxId(void) const;
        Tizen::Graphics::Bitmap* GetAppIconBitmap(void) const;
        Tizen::Graphics::Bitmap* GetBitmap(void) const;
        bool IsUpdated(void) const;
-       Tizen::Graphics::Dimension GetAnchorSize(void) const;
+       Tizen::Graphics::FloatDimension GetAnchorSize(void) const;
 
 protected:
        _LiveboxView(void);
@@ -88,7 +88,7 @@ private:
 
        struct livebox* GetNativeLivebox(void) const;
        result OpenLiveboxPopup(void);
-       void GetTouchPostion(const Tizen::Graphics::Point& point, double& x, double& y) const;
+       void GetTouchPostion(const Tizen::Graphics::FloatPoint& point, double& x, double& y) const;
        void PlayClickAnimation(void);
        void PlayFlickAnimation(void);
        void GetRemainingSpace(int& lower, int& upper) const;
@@ -105,7 +105,7 @@ private:
        virtual void OnLiveboxPopupViewClosed(void);
        virtual void OnDraw(void);
 
-       void OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::Dimension& size);
+       void OnLiveboxUpdated(const Tizen::Graphics::Bitmap& bitmap, const Tizen::Graphics::FloatDimension& size);
        void OnLiveboxUpdated(int pixmap);
 
        static Eina_Bool OnPixmapDamaged(void* pData, int type, void* pEvent);

diff --git a/src/FShell_LiveboxViewImpl.cpp b/src/FShell_LiveboxViewImpl.cpp
index f73d9a7..31480b5 100644 (file)
--- a/src/FShell_LiveboxViewImpl.cpp
+++ b/src/FShell_LiveboxViewImpl.cpp
@@ -100,7 +100,7 @@ _LiveboxViewImpl::GetCore(void)
 }
 
 result
-_LiveboxViewImpl::Initialize(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const String& userInfo)
+_LiveboxViewImpl::Initialize(const AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect, const String& userInfo)
 {
        result r = GetCore().Initialize(appId, providerName, rect, userInfo);
        SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));

diff --git a/src/FShell_LiveboxViewImpl.h b/src/FShell_LiveboxViewImpl.h
index 39b57c9..66b6c6b 100644 (file)
--- a/src/FShell_LiveboxViewImpl.h
+++ b/src/FShell_LiveboxViewImpl.h
@@ -30,6 +30,7 @@ class String;
 namespace Tizen { namespace Graphics
 {
 class Point;
+class FloatRectangle;
 }}
 
 namespace Tizen { namespace Shell
@@ -51,7 +52,7 @@ public:
        virtual const _LiveboxView& GetCore(void) const;
        virtual _LiveboxView& GetCore(void);
 
-       result Initialize(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::Rectangle& rect, const Tizen::Base::String& userInfo);
+       result Initialize(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, const Tizen::Graphics::FloatRectangle& rect, const Tizen::Base::String& userInfo);
 
 protected:
        _LiveboxViewImpl(LiveboxView* pPublic, _LiveboxView* pCore);

diff --git a/src/FShell_LiveboxViewManager.cpp b/src/FShell_LiveboxViewManager.cpp
index 068a475..9e6470a 100644 (file)
--- a/src/FShell_LiveboxViewManager.cpp
+++ b/src/FShell_LiveboxViewManager.cpp
@@ -357,7 +357,7 @@ _LiveboxViewManager::AddLiveboxView(_LiveboxView* pLiveboxView, const String& us
        const char* pCluster = "user,created";
        const char* pCategory = "default";
        double period = 1.0f;
-       int sizeType = GetLiveboxSizeType(pLiveboxView->GetSize());
+       int sizeType = GetLiveboxSizeType(pLiveboxView->GetSizeF());
 
        livebox* pLivebox = livebox_add_with_size(pLiveboxId.get(), pContent.get(), pCluster, pCategory, period, sizeType, OnLiveboxAdded, this);
        SysTryReturn(NID_UI_CTRL, pLivebox, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
@@ -391,10 +391,10 @@ _LiveboxViewManager::GetLiveboxView(livebox* pLivebox) const
        return pLiveboxView;
 }
 
-Dimension
+FloatDimension
 _LiveboxViewManager::GetLiveboxSize(livebox* pLivebox) const
 {
-       SysTryReturn(NID_UI_CTRL, pLivebox, Dimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
+       SysTryReturn(NID_UI_CTRL, pLivebox, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 
        int width = 0;
        int height = 0;
@@ -404,13 +404,13 @@ _LiveboxViewManager::GetLiveboxSize(livebox* pLivebox) const
 
 //     SysLog(NID_UI_CTRL, "size [%d %d]", width, height);
 
-       return Dimension(width, height);
+       return FloatDimension(width, height);
 }
 
-Dimension
+FloatDimension
 _LiveboxViewManager::GetLiveboxPopupSize(livebox* pLivebox) const
 {
-       SysTryReturn(NID_UI_CTRL, pLivebox, Dimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
+       SysTryReturn(NID_UI_CTRL, pLivebox, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 
        int width = 0;
        int height = 0;
@@ -419,11 +419,11 @@ _LiveboxViewManager::GetLiveboxPopupSize(livebox* pLivebox) const
 
 //     SysLog(NID_UI_CTRL, "size [%d %d]", width, height);
 
-       return Dimension(width, height);
+       return FloatDimension(width, height);
 }
 
 void
-_LiveboxViewManager::SetLiveboxSize(const _LiveboxView& liveboxView, const Dimension& size)
+_LiveboxViewManager::SetLiveboxSize(const _LiveboxView& liveboxView, const FloatDimension& size)
 {
        livebox* pLivebox = liveboxView.GetNativeLivebox();
        SysTryReturnVoidResult(NID_UI_CTRL, pLivebox, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
@@ -466,7 +466,7 @@ _LiveboxViewManager::~_LiveboxViewManager(void)
 }
 
 int
-_LiveboxViewManager::GetLiveboxSizeType(const Tizen::Graphics::Dimension& size) const
+_LiveboxViewManager::GetLiveboxSizeType(const Tizen::Graphics::FloatDimension& size) const
 {
        int sizeType = LB_SIZE_TYPE_UNKNOWN;
 
@@ -529,7 +529,7 @@ _LiveboxViewManager::GetBitmapN(const String& fileName) const
 }
 
 Bitmap*
-_LiveboxViewManager::GetBitmapN(void* pBuffer, const Dimension& size) const
+_LiveboxViewManager::GetBitmapN(void* pBuffer, const FloatDimension& size) const
 {
        SysTryReturn(NID_UI_CTRL, pBuffer, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 
@@ -612,7 +612,7 @@ _LiveboxViewManager::OnLiveboxUpdated(livebox* pLivebox)
                        void* pBuffer = livebox_acquire_fb(pLivebox);
                        SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 
-                       Dimension sourceSize = GetLiveboxSize(pLivebox);
+                       FloatDimension sourceSize = GetLiveboxSize(pLivebox);
                        SysLog(NID_UI_CTRL, "size [%d %d]", sourceSize.width, sourceSize.height);
 
                        unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
@@ -638,7 +638,7 @@ _LiveboxViewManager::OnLiveboxUpdated(livebox* pLivebox)
                        void* pBuffer = livebox_acquire_fb(pLivebox);
                        SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 
-                       Dimension sourceSize = GetLiveboxSize(pLivebox);
+                       FloatDimension sourceSize = GetLiveboxSize(pLivebox);
 
                        unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
                        SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
@@ -684,7 +684,7 @@ _LiveboxViewManager::OnLiveboxPopupUpdated(livebox* pLivebox)
                        void* pBuffer = livebox_acquire_pdfb(pLivebox);
                        SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 
-                       Dimension sourceSize = GetLiveboxPopupSize(pLivebox);
+                       FloatDimension sourceSize = GetLiveboxPopupSize(pLivebox);
 
                        unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
                        SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
@@ -708,7 +708,7 @@ _LiveboxViewManager::OnLiveboxPopupUpdated(livebox* pLivebox)
                        void* pBuffer = livebox_acquire_pdfb(pLivebox);
                        SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 
-                       Dimension sourceSize = GetLiveboxPopupSize(pLivebox);
+                       FloatDimension sourceSize = GetLiveboxPopupSize(pLivebox);
 
                        unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
                        SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");

diff --git a/src/FShell_LiveboxViewManager.h b/src/FShell_LiveboxViewManager.h
index 9d1ed37..8015235 100644 (file)
--- a/src/FShell_LiveboxViewManager.h
+++ b/src/FShell_LiveboxViewManager.h
@@ -42,7 +42,7 @@ template<class KeyType, class ValueType> class HashMapT;
 namespace Tizen { namespace Graphics
 {
 class Bitmap;
-class Dimension;
+class FloatDimension;
 class _ICoordinateSystemTransformer;
 }} // Tizen::Graphics
 
@@ -62,9 +62,9 @@ public:
        livebox* AddLiveboxView(_LiveboxView* pLiveboxView, const Tizen::Base::String& userInfo);
        void RemoveLiveboxView(_LiveboxView* pLiveboxView);
        _LiveboxView* GetLiveboxView(livebox* pLivebox) const;
-       Tizen::Graphics::Dimension GetLiveboxSize(livebox* pLivebox) const;
-       Tizen::Graphics::Dimension GetLiveboxPopupSize(livebox* pLivebox) const;
-       void SetLiveboxSize(const _LiveboxView& liveboxView, const Tizen::Graphics::Dimension& size);
+       Tizen::Graphics::FloatDimension GetLiveboxSize(livebox* pLivebox) const;
+       Tizen::Graphics::FloatDimension GetLiveboxPopupSize(livebox* pLivebox) const;
+       void SetLiveboxSize(const _LiveboxView& liveboxView, const Tizen::Graphics::FloatDimension& size);
 
 private:
        _LiveboxViewManager(void);
@@ -72,10 +72,10 @@ private:
        _LiveboxViewManager(const _LiveboxViewManager& rhs);
        _LiveboxViewManager& operator =(const _LiveboxViewManager& rhs);
 
-       int GetLiveboxSizeType(const Tizen::Graphics::Dimension& size) const;
+       int GetLiveboxSizeType(const Tizen::Graphics::FloatDimension& size) const;
        Tizen::Media::MediaPixelFormat GetPixelFormat(Tizen::Graphics::BitmapPixelFormat format) const;
        Tizen::Graphics::Bitmap* GetBitmapN(const Tizen::Base::String& fileName) const;
-       Tizen::Graphics::Bitmap* GetBitmapN(void* pBuffer, const Tizen::Graphics::Dimension& size) const;
+       Tizen::Graphics::Bitmap* GetBitmapN(void* pBuffer, const Tizen::Graphics::FloatDimension& size) const;
        bool IsGlMode(void) const;
 
        void OnLiveboxCreated(livebox* pLivebox);