BuildRequires: pkgconfig(appsvc)
BuildRequires: pkgconfig(pkgmgr)
BuildRequires: pkgconfig(minicontrol-provider)
-BuildRequires: pkgconfig(x11)
-BuildRequires: pkgconfig(xext)
-BuildRequires: pkgconfig(xfixes)
+BuildRequires: pkgconfig(x11)
+BuildRequires: pkgconfig(xext)
+BuildRequires: pkgconfig(xfixes)
+BuildRequires: pkgconfig(xdamage)
+BuildRequires: pkgconfig(libdri2)
+BuildRequires: pkgconfig(libdrm)
+BuildRequires: pkgconfig(libtbm)
+BuildRequires: pkgconfig(dri2proto)
BuildRequires: pkgconfig(glib-2.0)
BuildRequires: pkgconfig(provider)
BuildRequires: pkgconfig(livebox-viewer)
FShellAppWidgetManager.cpp
FShellAppWidgetProviderManager.cpp
FShell_AppWidgetManagerIpcMessage.cpp
+ FShell_AppWidgetBuffer.cpp
FShell_AppWidgetFrame.cpp
FShell_AppWidgetFrameImpl.cpp
FShell_AppWidgetFrameModel.cpp
TARGET_LINK_LIBRARIES(${this_target} "-llivebox-service" )
TARGET_LINK_LIBRARIES(${this_target} "-lprovider" )
TARGET_LINK_LIBRARIES(${this_target} "-lshortcut" )
-IF (NOT OSP_EMUL)
TARGET_LINK_LIBRARIES(${this_target} "-ldri2" )
TARGET_LINK_LIBRARIES(${this_target} "-ldrm" )
-ENDIF (NOT OSP_EMUL)
+TARGET_LINK_LIBRARIES(${this_target} "-ltbm" )
SET_TARGET_PROPERTIES(${this_target}
PROPERTIES
--- /dev/null
+//
+// Open Service Platform
+// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Flora License, Version 1.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://floralicense.org/license/
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+/**
+ * @file FShell_AppWidgetBuffer.cpp
+ * @brief This is the implementation file for the _AppWidgetBuffer class.
+ */
+
+#include <new>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <sys/shm.h>
+#include <sys/ipc.h>
+#include <FBaseSysLog.h>
+#include "FShell_AppWidgetBuffer.h"
+
+using namespace std;
+using namespace Tizen::Base;
+using namespace Tizen::Graphics;
+//using namespace Tizen::Ui::Animations;
+//using namespace Tizen::Ui;
+
+namespace Tizen { namespace Shell
+{
+
+_AppWidgetBuffer::_AppWidgetBuffer(void)
+ : __screen(0)
+ , __pVisual(null)
+ , __dri2FileDescriptor(-1)
+{
+}
+
+_AppWidgetBuffer::~_AppWidgetBuffer(void)
+{
+}
+
+struct _Deleter
+{
+ void operator()(char* pStr)
+ {
+ free(pStr);
+ }
+};
+
+void
+_AppWidgetBuffer::Initialize(void)
+{
+ __pDisplay.reset(XOpenDisplay(null));
+ SysTryReturnVoidResult(NID_SHELL, __pDisplay, E_SYSTEM, "[E_SYSTEM] Propagating.");
+
+ Screen* pScreen = DefaultScreenOfDisplay(__pDisplay.get());
+ __screen = DefaultScreen(__pDisplay.get());
+ __pVisual = DefaultVisualOfScreen(pScreen);
+ SysTryReturnVoidResult(NID_SHELL, __pVisual, E_SYSTEM, "[E_SYSTEM] Propagating.");
+
+ Bool ret = False;
+ int eventBase = 0;
+ int errorBase = 0;
+ ret = DRI2QueryExtension(__pDisplay.get(), &eventBase, &errorBase);
+ if (!ret)
+ {
+ SysLog(NID_SHELL, "Do not support");
+ return;
+ }
+
+ int dri2Major = 0;
+ int dri2Minor = 0;
+ ret = DRI2QueryVersion(__pDisplay.get(), &dri2Major, &dri2Minor);
+ if (!ret)
+ {
+ SysLog(NID_SHELL, "Do not support");
+ return;
+ }
+
+ char* pDriverNameTemp = null;
+ char* pDeviceNameTemp = null;
+
+ ret = DRI2Connect(__pDisplay.get(), DefaultRootWindow(__pDisplay.get()), &pDriverNameTemp, &pDeviceNameTemp);
+ if (!ret)
+ {
+ SysLog(NID_SHELL, "Do not support");
+ return;
+ }
+
+ unique_ptr<char, _Deleter> pDriverName(pDriverNameTemp);
+ unique_ptr<char, _Deleter> pDeviceName(pDeviceNameTemp);
+
+ unique_ptr<int, _FileDescriptorDeleter> fileDescriptor(open(pDeviceName.get(), O_RDWR));
+ if (fileDescriptor.get() < 0)
+ {
+ SysLog(NID_SHELL, "Do not support");
+ return;
+ }
+
+ drm_magic_t magic = 0;
+ drmGetMagic(fileDescriptor.get(), &magic);
+ SysLog(NID_SHELL, "Magic [0x%x]", magic);
+ ret = DRI2Authenticate(__pDisplay.get(), DefaultRootWindow(__pDisplay.get()), magic);
+ SysTryReturnVoidResult(NID_SHELL, ret == True, E_SYSTEM, "[E_SYSTEM] Propagating.");
+
+ unique_ptr<tbm_bufmgr, _TbmBufMgrDeleter> pBufMgr(tbm_bufmgr_init(fileDescriptor.get()));
+ SysTryReturnVoidResult(NID_SHELL, pBufMgr, E_SYSTEM, "[E_SYSTEM] Propagating.");
+
+ __dri2FileDescriptor = move(fileDescriptor);
+ __pBufMgr = move(pBufMgr);
+}
+
+void*
+_AppWidgetBuffer::AllocBuffer(Pixmap pixmap, const Tizen::Graphics::FloatDimension& size)
+{
+ unique_ptr<_Buffer> pBuffer;
+
+ if (!IsGemBufferEnabled())
+ {
+ pBuffer.reset(new (std::nothrow) _Buffer(this));
+ }
+ else
+ {
+ pBuffer.reset(new (std::nothrow) _GemBuffer(this));
+ }
+
+ SysTryReturn(NID_SHELL, pBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ void* pNativeBuffer = pBuffer->AllocBuffer(pixmap, size);
+ SysTryReturn(NID_SHELL, pNativeBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __pBuffer = move(pBuffer);
+
+ return pNativeBuffer;
+}
+
+void
+_AppWidgetBuffer::DeallocBuffer(void)
+{
+ SysTryReturnVoidResult(NID_SHELL, __pBuffer, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __pBuffer->DeallocBuffer();
+}
+
+void*
+_AppWidgetBuffer::LockBuffer(void)
+{
+ SysTryReturn(NID_SHELL, __pBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ void* pNativeBuffer = __pBuffer->LockBuffer();
+ SysTryReturn(NID_SHELL, pNativeBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ return pNativeBuffer;
+}
+
+void
+_AppWidgetBuffer::UnlockBuffer(void)
+{
+ SysTryReturnVoidResult(NID_SHELL, __pBuffer, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __pBuffer->UnlockBuffer();
+}
+
+bool
+_AppWidgetBuffer::IsGemBufferEnabled(void) const
+{
+ return (__dri2FileDescriptor.get() >= 0);
+}
+
+Display*
+_AppWidgetBuffer::GetDisplay(void) const
+{
+ return __pDisplay.get();
+}
+
+GC
+_AppWidgetBuffer::GetGc(void) const
+{
+ SysTryReturn(NID_SHELL, __pBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ return __pBuffer->GetGc();
+}
+
+XImage*
+_AppWidgetBuffer::GetXImage(void) const
+{
+ SysTryReturn(NID_SHELL, __pBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ return __pBuffer->GetXImage();
+}
+
+_AppWidgetBuffer::_Buffer::_Buffer(_AppWidgetBuffer* pAppWidgetBuffer)
+ : __allocated(false)
+ , __locked(false)
+ , __pixmap(0)
+ , __depth(sizeof(int))
+ , __pAppWidgetBuffer(pAppWidgetBuffer)
+ , __gc(null)
+ , __pXImage(null)
+{
+}
+
+_AppWidgetBuffer::_Buffer::~_Buffer(void)
+{
+ DeleteBuffer();
+}
+
+void*
+_AppWidgetBuffer::_Buffer::AllocBuffer(Pixmap pixmap, const Tizen::Graphics::FloatDimension& size)
+{
+ __pixmap = pixmap;
+ __size = size;
+
+ OnCreateBuffer();
+
+ __allocated = true;
+
+ return LockBuffer();
+}
+
+void
+_AppWidgetBuffer::_Buffer::DeallocBuffer(void)
+{
+ OnDeleteBuffer();
+
+ __allocated = false;
+}
+
+void*
+_AppWidgetBuffer::_Buffer::LockBuffer(void)
+{
+ __locked = true;
+
+ return OnLockBuffer();
+}
+
+void
+_AppWidgetBuffer::_Buffer::UnlockBuffer(void)
+{
+ __locked = false;
+
+ return OnUnlockBuffer();
+}
+
+GC
+_AppWidgetBuffer::_Buffer::GetGc(void) const
+{
+ return __gc;
+}
+
+XImage*
+_AppWidgetBuffer::_Buffer::GetXImage(void) const
+{
+ return __pXImage;
+}
+
+void
+_AppWidgetBuffer::_Buffer::DeleteBuffer(void)
+{
+ if (__allocated)
+ {
+ XFreeGC(__pAppWidgetBuffer->__pDisplay.get(), __gc);
+ XShmDetach(__pAppWidgetBuffer->__pDisplay.get(), &__xShmSegmentInfo);
+ XDestroyImage(__pXImage);
+
+ if (__xShmSegmentInfo.shmaddr != (void *)-1)
+ {
+ shmdt(__xShmSegmentInfo.shmaddr);
+ }
+
+ if (__xShmSegmentInfo.shmid >= 0)
+ {
+ shmctl(__xShmSegmentInfo.shmid, IPC_RMID, 0);
+ }
+ }
+
+ __allocated = false;
+}
+
+void
+_AppWidgetBuffer::_Buffer::OnCreateBuffer(void)
+{
+ int bufferSize = static_cast<int>(__size.width) * static_cast<int>(__size.height) * __depth;
+ SysLog(NID_SHELL, "%d [%f %f %d]", bufferSize, __size.width, __size.height, __depth);
+
+ __xShmSegmentInfo.shmid = shmget(IPC_PRIVATE, bufferSize, IPC_CREAT | 0666);
+ SysTryReturnVoidResult(NID_SHELL, __xShmSegmentInfo.shmid >= 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __xShmSegmentInfo.readOnly = False;
+ __xShmSegmentInfo.shmaddr = static_cast<char*>(shmat(__xShmSegmentInfo.shmid, null, 0));
+ SysTryCatch(NID_SHELL, __xShmSegmentInfo.shmaddr != (void*)-1, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __pXImage = XShmCreateImage(__pAppWidgetBuffer->__pDisplay.get(), __pAppWidgetBuffer->__pVisual, 32, ZPixmap, null, &__xShmSegmentInfo, __size.width, __size.height);
+ SysTryCatch(NID_SHELL, __pXImage, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ __pXImage->data = __xShmSegmentInfo.shmaddr;
+ XShmAttach(__pAppWidgetBuffer->__pDisplay.get(), &__xShmSegmentInfo);
+ XSync(__pAppWidgetBuffer->__pDisplay.get(), False);
+
+ __gc = XCreateGC(__pAppWidgetBuffer->__pDisplay.get(), static_cast<Pixmap>(__pixmap), 0, null);
+ SysTryCatch(NID_SHELL, __gc, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+ return;
+
+CATCH:
+
+ XShmDetach(__pAppWidgetBuffer->__pDisplay.get(), &__xShmSegmentInfo);
+
+ if (__pXImage)
+ {
+ XDestroyImage(__pXImage);
+ __pXImage = null;
+ }
+
+ if (__xShmSegmentInfo.shmaddr != (void *)-1)
+ {
+ shmdt(__xShmSegmentInfo.shmaddr);
+ }
+
+ if (__xShmSegmentInfo.shmid >= 0)
+ {
+ shmctl(__xShmSegmentInfo.shmid, IPC_RMID, 0);
+ }
+}
+
+void
+_AppWidgetBuffer::_Buffer::OnDeleteBuffer(void)
+{
+ DeleteBuffer();
+}
+
+void*
+_AppWidgetBuffer::_Buffer::OnLockBuffer(void)
+{
+ return __xShmSegmentInfo.shmaddr;
+}
+
+void
+_AppWidgetBuffer::_Buffer::OnUnlockBuffer(void)
+{
+// DeleteBuffer();
+}
+
+_AppWidgetBuffer::_GemBuffer::_GemBuffer(_AppWidgetBuffer* pAppWidgetBuffer)
+ : _Buffer(pAppWidgetBuffer)
+ , __pDri2Buffer(null)
+ , __count(1)
+ , __outCount(0)
+ , __pTbmBo(null)
+ , __pGemBuffer(null)
+ , __pCompensateBuffer(null)
+{
+ __attachments[0] = DRI2BufferFrontLeft;
+}
+
+_AppWidgetBuffer::_GemBuffer::~_GemBuffer(void)
+{
+ DeleteGemBuffer();
+}
+
+void
+_AppWidgetBuffer::_GemBuffer::DeleteGemBuffer(void)
+{
+ if (__pCompensateBuffer)\r
+ {\r
+ free(__pCompensateBuffer);\r
+ __pCompensateBuffer = null;\r
+ }\r
+\r
+ if (__pTbmBo)\r
+ {\r
+ tbm_bo_unref(__pTbmBo);\r
+ __pTbmBo = null;\r
+\r
+ DRI2DestroyDrawable(__pAppWidgetBuffer->__pDisplay.get(), __pixmap);\r
+ }
+}
+
+void
+_AppWidgetBuffer::_GemBuffer::OnCreateBuffer(void)
+{
+ SysLog(NID_SHELL, "[%f %f]", __size.width, __size.height);\r
+\r
+ unsigned int pitch = 0;\r
+\r
+ DRI2CreateDrawable(__pAppWidgetBuffer->__pDisplay.get(), __pixmap);\r
+\r
+ int width = static_cast<int>(__size.width);\r
+ int height = static_cast<int>(__size.height);\r
+\r
+ __pDri2Buffer = DRI2GetBuffers(__pAppWidgetBuffer->__pDisplay.get(), __pixmap, &width, &height, __attachments, __count, &__outCount);\r
+ SysTryCatch(NID_SHELL, __pDri2Buffer && __pDri2Buffer->name, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");\r
+\r
+ __gemSize.width = width;\r
+ __gemSize.height = height;\r
+\r
+ SysLog(NID_SHELL, "0x%x [%d %d %d] [%d %d]", __pDri2Buffer, __outCount, __pDri2Buffer->name, __pDri2Buffer->pitch, width, height);\r
+\r
+ __pTbmBo = tbm_bo_import(__pAppWidgetBuffer->__pBufMgr.get(), __pDri2Buffer->name);\r
+ SysTryCatch(NID_SHELL, __pTbmBo, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");\r
+ \r
+ pitch = __gemSize.width * __depth;\r
+ if (__pDri2Buffer->pitch != pitch)\r
+ {\r
+ __pCompensateBuffer = calloc(1, pitch * __gemSize.height);\r
+ SysTryCatch(NID_SHELL, __pCompensateBuffer, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");\r
+\r
+ SysLog(NID_SHELL, "0x%x [%d %d %d]", __pCompensateBuffer, __depth, __gemSize.width, __gemSize.height);\r
+ }\r
+\r
+ return;\r
+\r
+CATCH:\r
+\r
+ DRI2DestroyDrawable(__pAppWidgetBuffer->__pDisplay.get(), __pixmap);
+}
+
+void
+_AppWidgetBuffer::_GemBuffer::OnDeleteBuffer(void)
+{
+ DeleteGemBuffer();
+}
+
+void*
+_AppWidgetBuffer::_GemBuffer::OnLockBuffer(void)
+{
+ if (!__pGemBuffer)
+ {
+ tbm_bo_handle handle;\r
+ handle = tbm_bo_map(__pTbmBo, TBM_DEVICE_CPU, TBM_OPTION_READ | TBM_OPTION_WRITE);\r
+ __pGemBuffer = handle.ptr;
+ }
+
+ return __pCompensateBuffer ? __pCompensateBuffer : __pGemBuffer;
+}
+
+void
+_AppWidgetBuffer::_GemBuffer::OnUnlockBuffer(void)
+{
+ if (__pCompensateBuffer)\r
+ {\r
+ int* pPixel = (int*)__pCompensateBuffer;\r
+ int* pGemPixel = (int*)__pGemBuffer;\r
+ int gap = __pDri2Buffer->pitch - (__gemSize.width * __depth);\r
+\r
+ for (int y = 0; y < __gemSize.height; y++)\r
+ {\r
+ for (int x = 0; x < __gemSize.width; x++)\r
+ {\r
+ *pGemPixel++ = *pPixel++;\r
+ }\r
+\r
+ pGemPixel = (int*)(((char*)pGemPixel) + gap);\r
+ }\r
+ }\r
+\r
+ tbm_bo_unmap(__pTbmBo);\r
+ __pGemBuffer = null;
+}
+
+}} // Tizen::Shell
--- /dev/null
+//
+// Open Service Platform
+// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Flora License, Version 1.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://floralicense.org/license/
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+/**
+ * @file FShell_AppWidgetBuffer.h
+ * @brief This is the header file for the _AppWidgetBuffer class.
+ *
+ * This header file contains the declarations of the %_AppWidgetBuffer class.
+ */
+#ifndef _FSHELL_INTERNAL_APPWIDGET_BUFFER_H_
+#define _FSHELL_INTERNAL_APPWIDGET_BUFFER_H_
+
+#include <unique_ptr.h>
+extern "C"
+{
+#include <X11/Xlib.h>
+#include <X11/extensions/XShm.h>
+#include <X11/Xutil.h>
+#include <X11/Xproto.h>
+#include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xfixes.h>
+#include <dri2.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <tbm_bufmgr.h>
+}
+#include <FBaseDataType.h>
+#include <FGrpDimension.h>
+#include <FGrpFloatDimension.h>
+
+namespace Tizen { namespace Graphics
+{
+class FloatDimension;
+}} // Tizen::Graphics
+
+namespace Tizen { namespace Shell
+{
+
+/**
+ * @class _AppWidgetBuffer
+ * @brief
+ * @since 2.1
+ */
+class _AppWidgetBuffer
+{
+public:
+ _AppWidgetBuffer(void);
+ ~_AppWidgetBuffer(void);
+
+ void Initialize(void);
+ void* AllocBuffer(Pixmap pixmap, const Tizen::Graphics::FloatDimension& size);
+ void DeallocBuffer(void);
+ void* LockBuffer(void);
+ void UnlockBuffer(void);
+ bool IsGemBufferEnabled(void) const;
+ Display* GetDisplay(void) const;
+ GC GetGc(void) const;
+ XImage* GetXImage(void) const;
+
+private:
+ _AppWidgetBuffer(const _AppWidgetBuffer& rhs);
+ _AppWidgetBuffer& operator =(const _AppWidgetBuffer& rhs);
+
+private:
+ class _Buffer
+ {
+ public:
+ _Buffer(_AppWidgetBuffer* pAppWidgetBuffer);
+ virtual ~_Buffer(void);
+ void* AllocBuffer(Pixmap pixmap, const Tizen::Graphics::FloatDimension& size);
+ void DeallocBuffer(void);
+ void* LockBuffer(void);
+ void UnlockBuffer(void);
+ GC GetGc(void) const;
+ XImage* GetXImage(void) const;
+
+ private:
+ _Buffer(const _Buffer& rhs);
+ _Buffer& operator =(const _Buffer& rhs);
+ void DeleteBuffer(void);
+ virtual void OnCreateBuffer(void);
+ virtual void OnDeleteBuffer(void);
+ virtual void* OnLockBuffer(void);
+ virtual void OnUnlockBuffer(void);
+
+ protected:
+ bool __allocated;
+ bool __locked;
+ Pixmap __pixmap;
+ int __depth;
+ Tizen::Graphics::FloatDimension __size;
+ _AppWidgetBuffer* __pAppWidgetBuffer;
+
+ private:
+ GC __gc;
+ XImage* __pXImage;
+ XShmSegmentInfo __xShmSegmentInfo;
+ };
+
+ class _GemBuffer
+ : public _Buffer
+ {
+ public:
+ _GemBuffer(_AppWidgetBuffer* pAppWidgetBuffer);
+ virtual ~_GemBuffer(void);
+
+ private:
+ _GemBuffer(const _GemBuffer& rhs);
+ _GemBuffer& operator =(const _GemBuffer& rhs);
+ void DeleteGemBuffer(void);
+ virtual void OnCreateBuffer(void);
+ virtual void OnDeleteBuffer(void);
+ virtual void* OnLockBuffer(void);
+ virtual void OnUnlockBuffer(void);
+
+ private:
+ DRI2Buffer* __pDri2Buffer;
+ Tizen::Graphics::Dimension __gemSize;
+ int __count;
+ int __outCount;
+ unsigned int __attachments[1];
+ tbm_bo __pTbmBo;
+ void* __pGemBuffer;
+ void* __pCompensateBuffer;
+ };
+
+ Tizen::Graphics::FloatDimension __size;
+ int __screen;
+ Visual* __pVisual;
+
+ struct _FileDescriptorDeleter
+ {
+ typedef int pointer;
+
+ void operator()(int fileDescriptor)
+ {
+ close(fileDescriptor);
+ }
+ };
+ std::unique_ptr<int, _FileDescriptorDeleter> __dri2FileDescriptor;
+
+ struct _DisplayDeleter
+ {
+ void operator()(Display* pDisplay)
+ {
+ XCloseDisplay(pDisplay);
+ }
+ };
+ std::unique_ptr<Display, _DisplayDeleter> __pDisplay;
+
+ struct _TbmBufMgrDeleter
+ {
+ typedef tbm_bufmgr pointer;
+
+ void operator()(tbm_bufmgr pBufMgr)
+ {
+ tbm_bufmgr_deinit(pBufMgr);
+ }
+ };
+ std::unique_ptr<tbm_bufmgr, _TbmBufMgrDeleter> __pBufMgr;
+ std::unique_ptr<_Buffer> __pBuffer;
+};
+
+}} // Tizen::Shell
+
+#endif // _FSHELL_INTERNAL_APPWIDGET_BUFFER_H_
result
_AppWidgetFrame::Initialize(const FloatDimension& size)
{
- result r = E_SUCCESS;
-
- const float DEFAULT_WIDTH = 172.0f;
- const float DEFAULT_HEIGHT = 172.0f;
-
- FloatDimension appwidgetSize(size);
- if (appwidgetSize.width <= 0 )
- {
- appwidgetSize.width = DEFAULT_WIDTH;
- }
-
- if (appwidgetSize.height <= 0 )
- {
- appwidgetSize.height = DEFAULT_HEIGHT;
- }
-
SetSystemWindow(true);
__appwidgetSize = size;
- r = CreateRootVisualElement();
+ result r = __pAppWidgetFramePresenter->Initialize();
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
- FloatRectangle bounds(0.0f, 0.0f, appwidgetSize.width, appwidgetSize.height);
- r = SetBounds(bounds);
+ r = CreateRootVisualElement();
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
- r = __pAppWidgetFramePresenter->Initialize();
+ FloatRectangle bounds(0.0f, 0.0f, 1.0f, 1.0f);
+ r = SetBounds(bounds);
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
__pAppWidgetLayer->SetLayerBounds(bounds);
result r = __pAppWidgetLayer->SetProviderId(providerId);
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+ FloatRectangle bounds(0.0f, 0.0f, __appwidgetSize.width, __appwidgetSize.height);
+ r = SetBounds(bounds);
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+
return r;
}
result
_AppWidgetFrame::CreateLayer(void)
{
- unique_ptr<_AppWidgetLayer> pLayer(new (std::nothrow) _AppWidgetLayer(__appwidgetSize));
+ unique_ptr<_AppWidgetLayer> pLayer(new (std::nothrow) _AppWidgetLayer(GetProviderId(), GetSizeF()));
SysTryReturn(NID_SHELL, pLayer, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
result r = pLayer->Construct();
#include <FBase_StringConverter.h>
#include <FGrpRectangle.h>
#include "FUi_Window.h"
+#include "FShell_AppWidgetBuffer.h"
#include "FShell_AppWidgetLayer.h"
#include "FShell_AppWidgetProviderManagerImpl.h"
namespace Tizen { namespace Shell
{
-_AppWidgetLayer::_AppWidgetLayer(const FloatDimension& size)
+_AppWidgetLayer::_AppWidgetLayer(const Tizen::Base::String& providerId, const FloatDimension& size)
: __isReleased(false)
, __size(size)
, __pEcoreEvas(null)
, __pEvasObject(null)
- , __providerId(L"")
+ , __providerId(providerId)
, __pRenderBuffer(null)
+ , __pTempBuffer(null)
, __bufferSize(0)
, __pixmapId(-1)
+ , __pAppWidgetBuffer(new (std::nothrow) _AppWidgetBuffer)
{
}
_AppWidgetLayer::~_AppWidgetLayer(void)
{
__pRenderBuffer = null;
+ __pTempBuffer = null;
__pixmapId = -1;
}
{
result r = E_SUCCESS;
+ __pAppWidgetBuffer->Initialize();
+
unique_ptr<Ecore_Evas, _EcoreEvasDeleter> pEcoreEvas(ecore_evas_buffer_allocfunc_new(__size.width, __size.height, AllocRenderBuffer, FreeRenderBuffer, this));
SysTryReturn(NID_SHELL, pEcoreEvas, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
ecore_evas_alpha_set(__pEcoreEvas.get(), EINA_TRUE);
evas_object_color_set(__pEvasObject.get(), 0, 0, 0, 0);
+ if (!__providerId.IsEmpty())
+ {
+ r = RegisterTouchEventListener();
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+ }
+
return r;
}
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(bounds);
}
SysTryReturn(NID_SHELL, size > 0, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
__bufferSize = size;
- void* pBuffer = malloc(__bufferSize);
- SysTryReturn(NID_SHELL, pBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+ void* pBuffer = null;
+
+ if (__providerId.IsEmpty())
+ {
+ __pTempBuffer = malloc(__bufferSize);\r
+ SysTryReturn(NID_SHELL, __pTempBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");\r
+ \r
+ pBuffer = __pTempBuffer;\r
+ }\r
+ else\r
+ {
+ if (__pixmapId == -1)
+ {
+ __pixmapId = AcquirePixmap();
+ SysTryReturn(NID_SHELL, __pixmapId != -1, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+ }
- __pRenderBuffer = pBuffer;
+ __pRenderBuffer = __pAppWidgetBuffer->AllocBuffer(__pixmapId, __size);
+ pBuffer = __pRenderBuffer;
+ __pAppWidgetBuffer->UnlockBuffer();
+ }
- SysLog(NID_SHELL, "buffer (0x%x) size (%d)", pBuffer, __bufferSize);
+ SysLog(NID_SHELL, "buffer (0x%x 0x%x) size (%d) pixmap (%d)", __pTempBuffer, __pRenderBuffer, __bufferSize, __pixmapId);
__isReleased = false;
- return __pRenderBuffer;
+ return pBuffer;
}
void
_AppWidgetLayer::FreeCanvas(void* pCanvas)
{
- if (!__isReleased)
+ SysLog(NID_SHELL, "buffer (0x%x 0x%x 0x%x) size (%d)", __pTempBuffer, __pRenderBuffer, pCanvas, __bufferSize);
+
+ if (__pTempBuffer)
{
- ReleasePixmap();
- __isReleased = true;
+ free(__pTempBuffer);
+ __pTempBuffer = null;
+ }
+ else
+ {
+ if (__pAppWidgetBuffer)
+ {
+ __pAppWidgetBuffer->DeallocBuffer();
+ }
}
- if (pCanvas)
+ if (!__isReleased)
{
- free(pCanvas);
+ ReleasePixmap();
+ __isReleased = true;
}
__pixmapId = -1;
_AppWidgetLayer::SyncPixmap(const FloatDimension& size)
{
SysTryReturn(NID_SHELL, __pRenderBuffer, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+ SysTryReturn(NID_SHELL, __pAppWidgetBuffer, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
SysLog(NID_SHELL, "buffer (0x%x) size (%d) pixmapId (%d) width(%f) height(%f)", __pRenderBuffer, __bufferSize, __pixmapId, size.width, size.height);
- Display* pDisplay = static_cast<Display*>(ecore_x_display_get());
- SysTryReturn(NID_SHELL, pDisplay, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- result r = E_SUCCESS;
- XShmSegmentInfo xShmSegmentInfo;
- xShmSegmentInfo.shmseg = 0;
-
- XImage* pXImage = null;
- GC gc;
- Screen* pScreen = null;
- Visual* pVisual = null;
-
- xShmSegmentInfo.shmid = shmget(IPC_PRIVATE, __bufferSize, IPC_CREAT | 0666);
- SysTryReturn(NID_SHELL, xShmSegmentInfo.shmid >= 0, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- xShmSegmentInfo.readOnly = False;
- xShmSegmentInfo.shmaddr = static_cast<char*>(shmat(xShmSegmentInfo.shmid, null, 0));
- SysTryCatch(NID_SHELL, xShmSegmentInfo.shmaddr != (void *)-1, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- pScreen = DefaultScreenOfDisplay(pDisplay);
- SysTryCatch(NID_SHELL, pScreen, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- pVisual = DefaultVisualOfScreen(pScreen);
- SysTryCatch(NID_SHELL, pVisual, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- pXImage = XShmCreateImage(pDisplay, pVisual, 32, ZPixmap, null, &xShmSegmentInfo, size.width, size.height);
- SysTryCatch(NID_SHELL, pXImage, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- pXImage->data = xShmSegmentInfo.shmaddr;
- XShmAttach(pDisplay, &xShmSegmentInfo);
- XSync(pDisplay, False);
-
- gc = XCreateGC(pDisplay, static_cast<Pixmap>(__pixmapId), 0, null);
- SysTryCatch(NID_SHELL, gc, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
-
- memcpy(pXImage->data, __pRenderBuffer, __bufferSize);
-
-#if defined(_BUFFER_TEST)
- {
- FILE* pFile = null;
- static int idx = 0;
- char filename[1024];
- snprintf(filename, sizeof(filename), "/tmp/provider%d.raw", idx++);
- pFile = fopen(filename, "w+b");
- if (pFile)
- {
- fwrite(__pRenderBuffer, __bufferSize, 1, pFile);
- fclose(pFile);
- SysLog(NID_SHELL, "_BUFFER_TEST: buffer (0x%x) size (%d) pixmapId (%d) width(%f) height(%f)", __pRenderBuffer, __bufferSize, __pixmapId, size.width, size.height);
- }
- else
- {
- SysLog(NID_SHELL, "File open failed: (%s) buffer (0x%x) size (%d) pixmapId (%d)", strerror(errno), __pRenderBuffer, __bufferSize, __pixmapId);
- }
- }
-#endif // _BUFFER_TEST
-
- // Do not send the event. Instead of X event, master will send the updated event to the viewer
- XShmPutImage(pDisplay, static_cast<Pixmap>(__pixmapId), gc, pXImage, 0, 0, 0, 0, size.width, size.height, False);
- XSync(pDisplay, False);
-
- XFreeGC(pDisplay, gc);
- XShmDetach(pDisplay, &xShmSegmentInfo);
- XDestroyImage(pXImage);
-
- if (xShmSegmentInfo.shmaddr != (void *)-1)
- {
- shmdt(xShmSegmentInfo.shmaddr);
- }
-
- if (xShmSegmentInfo.shmid >= 0)
- {
- shmctl(xShmSegmentInfo.shmid, IPC_RMID, 0);
- }
-
- return r;
-
-CATCH:
-
- if (pDisplay)
- {
- XShmDetach(pDisplay, &xShmSegmentInfo);
- }
-
- if (pXImage)
- {
- XDestroyImage(pXImage);
- }
+ XShmPutImage(__pAppWidgetBuffer->GetDisplay(), static_cast<Pixmap>(__pixmapId), __pAppWidgetBuffer->GetGc(), __pAppWidgetBuffer->GetXImage(), 0, 0, 0, 0, size.width, size.height, False);
+ XSync(__pAppWidgetBuffer->GetDisplay(), False);
- if (xShmSegmentInfo.shmaddr != (void *)-1)
- {
- shmdt(xShmSegmentInfo.shmaddr);
- }
-
- if (xShmSegmentInfo.shmid >= 0)
- {
- shmctl(xShmSegmentInfo.shmid, IPC_RMID, 0);
- }
-
- return E_OUT_OF_MEMORY;
+ return E_SUCCESS;
}
void
_AppWidgetLayer::OnRendered(void)
{
- if (__pixmapId == -1)
+ result r = E_SUCCESS;
+
+ if (!__pAppWidgetBuffer->IsGemBufferEnabled())
{
- __pixmapId = AcquirePixmap();
- SysTryReturnVoidResult(NID_SHELL, __pixmapId >= 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
- }
+ if (__pixmapId == -1)
+ {
+ __pixmapId = AcquirePixmap();
+ SysTryReturnVoidResult(NID_SHELL, __pixmapId >= 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+ }
- result r = SyncPixmap(__size);
- SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+ r = SyncPixmap(__size);
+ SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+ }
r = Sync(__size);
SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
{
SysLog(NID_SHELL, "ENTER");
+ bool needed = IsFlushNeeded();
+
+ if (needed)
+ {
+ __pAppWidgetBuffer->LockBuffer();
+ }
+
_EflLayer::Flush();
- if (IsFlushNeeded())
+ if (needed)
{
OnRendered();
+
+ __pAppWidgetBuffer->UnlockBuffer();
}
}
// limitations under the License.
//
/**
- * @file FShell_AppWidgetFrame.h
+ * @file FShell_AppWidgetLayer.h
* @brief This is the header file for the _AppWidgetLayer class.
*
* This header file contains the declarations of the %_AppWidgetLayer class.
namespace Tizen { namespace Shell
{
+class _AppWidgetBuffer;
+
/**
* @class _AppWidgetLayer
* @brief
, public Tizen::Shell::_IAppWidgetTouchEventListener
{
public:
- _AppWidgetLayer(const Tizen::Graphics::FloatDimension& size);
+ _AppWidgetLayer(const Tizen::Base::String& providerId, const Tizen::Graphics::FloatDimension& size);
virtual ~_AppWidgetLayer(void);
virtual result OnConstructed(void);
private:
_AppWidgetLayer(const _AppWidgetLayer& rhs);
- _AppWidgetLayer& operator =(const _AppWidgetLayer& rhs);
+ _AppWidgetLayer& operator =(const _AppWidgetLayer& rhs);
virtual void Flush(void);
protected:
std::unique_ptr<Evas_Object, _EvasObjectDeleter> __pEvasObject;
Tizen::Base::String __providerId;
void* __pRenderBuffer;
+ void* __pTempBuffer;
int __bufferSize;
int __pixmapId;
+ std::unique_ptr<_AppWidgetBuffer> __pAppWidgetBuffer;
};
}} // Tizen::Shell
: public _AppWidgetLayer
{
public:
- _AppWidgetPopupLayer(const FloatDimension& size);
+ _AppWidgetPopupLayer(const Tizen::Base::String& providerId, const FloatDimension& size);
virtual ~_AppWidgetPopupLayer(void);
private:
virtual void ReleasePixmap(void);
};
-_AppWidgetPopupLayer::_AppWidgetPopupLayer(const FloatDimension& size)
- : _AppWidgetLayer(size)
+_AppWidgetPopupLayer::_AppWidgetPopupLayer(const Tizen::Base::String& providerId, const FloatDimension& size)
+ : _AppWidgetLayer(providerId, size)
{
}
SetSystemWindow(true);
- r = CreateRootVisualElement();
- SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
- FloatRectangle bounds(0.0f, 0.0f, size.width, size.height);
- r = SetBounds(bounds);
- SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
r = __pAppWidgetPopupPresenter->Initialize();
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
- __pAppWidgetPopupLayer->SetLayerBounds(bounds);
- __pAppWidgetPopupLayer->SetShowState(false);
-
- __pAppWidgetPopupRootVisualElement->SetImplicitAnimationEnabled(false);
- __pAppWidgetPopupRootVisualElement->SetName(L"_AppWidgetPopup");
- __pAppWidgetPopupRootVisualElement->SetBounds(bounds);
- __pAppWidgetPopupRootVisualElement->SetShowState(false);
-
- SetBackgroundColor(Color(0, 0, 0, 0));
-
- __pEventManager->RegisterTouchEventHandler(*this);
- r = GetLastResult();
+ r = CreateRootVisualElement();\r
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));\r
+\r
+ FloatRectangle bounds(0.0f, 0.0f, 1.0f, 1.0f);\r
+ r = SetBounds(bounds);\r
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));\r
+\r
+ r = __pAppWidgetPopupPresenter->Initialize();\r
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));\r
+\r
+ __pAppWidgetPopupLayer->SetLayerBounds(bounds);\r
+ __pAppWidgetPopupLayer->SetShowState(false);\r
+\r
+ __pAppWidgetPopupRootVisualElement->SetImplicitAnimationEnabled(false);\r
+ __pAppWidgetPopupRootVisualElement->SetName(L"_AppWidgetPopup");\r
+ __pAppWidgetPopupRootVisualElement->SetBounds(bounds);\r
+ __pAppWidgetPopupRootVisualElement->SetShowState(false);\r
+\r
+ SetBackgroundColor(Color(0, 0, 0, 0));\r
+\r
+ __pEventManager->RegisterTouchEventHandler(*this);\r
+ r = GetLastResult();\r
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
return r;
result r = __pAppWidgetPopupLayer->SetProviderId(providerId);
SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+ FloatRectangle bounds(0.0f, 0.0f, __appwidgetSize.width, __appwidgetSize.height);
+ r = SetBounds(bounds);
+ SysTryReturn(NID_SHELL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+
return r;
}
result
_AppWidgetPopup::CreateLayer(void)
{
- unique_ptr<_AppWidgetPopupLayer> pLayer(new (std::nothrow) _AppWidgetPopupLayer(__appwidgetSize));
+ unique_ptr<_AppWidgetPopupLayer> pLayer(new (std::nothrow) _AppWidgetPopupLayer(GetProviderId(), GetSizeF()));
SysTryReturn(NID_SHELL, pLayer, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
result r = pLayer->Construct();
__pPixmapEventHandler.reset(ecore_event_handler_add(ECORE_X_EVENT_DAMAGE_NOTIFY, OnPixmapDamaged, (void*)this));
SysTryReturnVoidResult(NID_SHELL, __pPixmapEventHandler, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
*/
- SysLog(NID_SHELL, "[0x%x][%d %d]", surface.data.x11.pixmap, absoluteBounds.x, absoluteBounds.y);
+ SysLog(NID_SHELL, "[0x%x][%f %f]", surface.data.x11.pixmap, absoluteBounds.x, absoluteBounds.y);
}
SysLog(NID_SHELL, "[%d %d %d %d]", x, y, width, height);
_AppWidgetViewImpl::AddAppWidgetViewEventListener(IAppWidgetViewEventListener& listener)
{
bool exist = __pAppWidgetViewEventListenerList->Contains(&listener);
- SysTryReturn(NID_SHELL, exist, E_OBJ_ALREADY_EXIST, E_OBJ_ALREADY_EXIST, "[%s] Propagating.", GetErrorMessage(E_OBJ_ALREADY_EXIST));
+ SysTryReturn(NID_SHELL, exist == false, E_OBJ_ALREADY_EXIST, E_OBJ_ALREADY_EXIST, "[%s] Propagating.", GetErrorMessage(E_OBJ_ALREADY_EXIST));
__pAppWidgetViewEventListenerList->Add(&listener);
projects / platform / framework / native / shell.git / commitdiff