return new DisplayConnection(internal);
}
+DisplayConnection* DisplayConnection::New( RenderSurface::Type type )
+{
+ Internal::Adaptor::DisplayConnection* internal(Internal::Adaptor::DisplayConnection::New());
+ internal->SetSurfaceType( type );
+
+ return new DisplayConnection(internal);
+}
+
DisplayConnection::DisplayConnection()
: mImpl( NULL )
{
#include <dali/public-api/object/any.h>
// INTERNAL INCLUDES
+#include <render-surface.h>
namespace Dali
static DisplayConnection* New();
/**
+ * @brief Create an initialized DisplayConnection.
+ *
+ * @return A handle to a newly allocated DisplayConnection resource.
+ */
+ static DisplayConnection* New( RenderSurface::Type type );
+
+ /**
* @brief Create a DisplayConnection handle; this can be initialised with DisplayConnection::New().
*
* Calling member functions with an uninitialised handle is not allowed.
// set the initial values before render thread starts
mSurface = adaptorInterfaces.GetRenderSurfaceInterface();
- mDisplayConnection = Dali::DisplayConnection::New();
+ if( mSurface )
+ {
+ mDisplayConnection = Dali::DisplayConnection::New( mSurface->GetSurfaceType() );
+ }
+ else
+ {
+ mDisplayConnection = Dali::DisplayConnection::New();
+ }
}
RenderHelper::~RenderHelper()
{
public:
+ enum Type
+ {
+ ECORE_RENDER_SURFACE,
+ WAYLAND_RENDER_SURFACE,
+ NATIVE_SOURCE_RENDER_SURFACE
+ };
+
/**
* @brief Constructor
* Inlined as this is a pure abstract interface
*/
virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization ) = 0;
+ virtual RenderSurface::Type GetSurfaceType() = 0;
+
private:
/**
#include <dali/integration-api/debug.h>
// INTERNAL HEADERS
-#include <pixmap-render-surface.h>
+#include <native-source-render-surface.h>
namespace Dali
{
}
DisplayConnection::DisplayConnection()
-: mDisplay(NULL)
{
- mDisplay = ecore_wl_display_get();
}
DisplayConnection::~DisplayConnection()
{
- //FIXME
+ if( mSurfaceType == RenderSurface::NATIVE_SOURCE_RENDER_SURFACE )
+ {
+ ReleaseNativeSourceDisplay();
+ }
}
Any DisplayConnection::GetDisplay()
{
- return Any(mDisplay);
+ return Any( mDisplay );
}
void DisplayConnection::ConsumeEvents()
{
EglImplementation& eglImpl = static_cast<EglImplementation&>(egl);
- if (!eglImpl.InitializeGles(reinterpret_cast<EGLNativeDisplayType>(mDisplay)))
+ if( !eglImpl.InitializeGles( mDisplay ) )
{
DALI_LOG_ERROR("Failed to initialize GLES.");
return false;
return true;
}
+void DisplayConnection::SetSurfaceType( RenderSurface::Type type )
+{
+ mSurfaceType = type;
+
+ if( mSurfaceType == RenderSurface::NATIVE_SOURCE_RENDER_SURFACE )
+ {
+ mDisplay = GetNativeSourceDisplay();
+ }
+ else
+ {
+ mDisplay = reinterpret_cast< EGLNativeDisplayType >( ecore_wl_display_get() );
+ }
+}
+
void DisplayConnection::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
{
// calculate DPI
*/
bool InitializeEgl(EglInterface& egl);
+ void SetSurfaceType( RenderSurface::Type type );
+
public:
/**
protected:
+ EGLNativeDisplayType GetNativeSourceDisplay();
+
+ void ReleaseNativeSourceDisplay();
+
// Undefined
DisplayConnection(const DisplayConnection&);
DisplayConnection& operator=(const DisplayConnection& rhs);
private:
- WlDisplay* mDisplay; ///< Wayland-display for rendering
+ EGLNativeDisplayType mDisplay; ///< Wayland-display for rendering
+ RenderSurface::Type mSurfaceType;
};
} // namespace Adaptor
return surfaceId;
}
+RenderSurface::Type EcoreWlRenderSurface::GetSurfaceType()
+{
+ return RenderSurface::ECORE_RENDER_SURFACE;
+}
+
} // namespace ECore
} // namespace Dali
$(adaptor_integration_api_dir)/thread-synchronization-interface.h \
$(adaptor_integration_api_dir)/trigger-event-interface.h \
$(adaptor_integration_api_dir)/trigger-event-factory-interface.h \
- $(adaptor_integration_api_dir)/trigger-event-factory.h \
- $(adaptor_integration_api_dir)/pixmap-render-surface-factory.h
+ $(adaptor_integration_api_dir)/trigger-event-factory.h
adaptor_integration_wayland_api_header_files = \
$(adaptor_integration_api_dir)/wayland/wl-types.h \
$(adaptor_integration_api_dir)/wayland/ecore-wl-render-surface.h \
- $(adaptor_integration_api_dir)/wayland/pixmap-render-surface.h
+ $(adaptor_integration_api_dir)/wayland/native-source-render-surface.h \
+ $(adaptor_integration_api_dir)/native-source-render-surface-factory.h
adaptor_integration_x11_api_header_files = \
$(adaptor_integration_api_dir)/x11/ecore-x-types.h \
$(adaptor_integration_api_dir)/x11/ecore-x-render-surface.h \
$(adaptor_integration_api_dir)/x11/pixmap-render-surface.h \
- $(adaptor_integration_api_dir)/x11/imf-manager-impl.h
+ $(adaptor_integration_api_dir)/x11/imf-manager-impl.h \
+ $(adaptor_integration_api_dir)/pixmap-render-surface-factory.h
--- /dev/null
+#ifndef __DALI_INTEGRATION_NATIVE_SOURCE_RENDER_SURFACE_FACTORY_H__
+#define __DALI_INTEGRATION_NATIVE_SOURCE_RENDER_SURFACE_FACTORY_H__
+
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <string>
+#include <dali/public-api/object/any.h>
+#include <dali/public-api/common/dali-common.h>
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+
+class NativeSourceRenderSurface;
+
+/**
+ * Surface factory function for native source
+ * A native source surface is created.
+ *
+ * @param [in] positionSize the position and size of the surface to create
+ * @param [in] name Name of surface passed in
+ * @param [in] isTransparent Whether the surface has an alpha channel
+ */
+NativeSourceRenderSurface* CreateNativeSourceSurface( PositionSize positionSize,
+ const std::string& name,
+ bool isTransparent );
+
+} // namespace Dali
+
+#endif // __DALI_INTEGRATION_NATIVE_SOURCE_RENDER_SURFACE_FACTORY_H__
#include <dali/public-api/signals/callback.h>
// INTERNAL INCLUDES
+#ifdef DALI_ADAPTOR_COMPILATION
#include <trigger-event-interface.h>
+#else
+#include <dali/integration-api/adaptors/trigger-event-interface.h>
+#endif
namespace Dali
{
*/
// INTERNAL INCLUDES
-#include <trigger-event-factory-interface.h>
#include <dali/public-api/common/dali-common.h>
+#ifdef DALI_ADAPTOR_COMPILATION
+#include <trigger-event-factory-interface.h>
+#else
+#include <dali/integration-api/adaptors/trigger-event-factory-interface.h>
+#endif
namespace Dali
{
*/
virtual void ReleaseLock() = 0;
+ /**
+ * @copydoc Dali::RenderSurface::GetSurfaceType()
+ */
+ virtual RenderSurface::Type GetSurfaceType();
+
private:
/**
--- /dev/null
+#ifndef __DALI_TIZEN_BUFFER_RENDER_SURFACE_H__
+#define __DALI_TIZEN_BUFFER_RENDER_SURFACE_H__
+
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <tbm_surface.h>
+#include <dali/public-api/common/dali-common.h>
+
+// INTERNAL INCLUDES
+#ifdef DALI_ADAPTOR_COMPILATION
+#include <render-surface.h>
+#include <egl-interface.h>
+#else
+#include <dali/devel-api/adaptor-framework/render-surface.h>
+#include <dali/integration-api/adaptors/egl-interface.h>
+#endif
+
+namespace Dali
+{
+
+class TriggerEventInterface;
+
+/**
+ * Ecore X11 implementation of render surface.
+ */
+class DALI_IMPORT_API NativeSourceRenderSurface : public Dali::RenderSurface
+{
+public:
+
+ /**
+ * Uses an Wayland surface to render to.
+ * @param [in] positionSize the position and size of the surface
+ * @param [in] name optional name of surface passed in
+ * @param [in] isTransparent if it is true, surface has 32 bit color depth, otherwise, 24 bit
+ */
+ NativeSourceRenderSurface( Dali::PositionSize positionSize,
+ const std::string& name,
+ bool isTransparent = false );
+
+ /**
+ * @copydoc Dali::RenderSurface::~RenderSurface
+ */
+ virtual ~NativeSourceRenderSurface();
+
+public: // API
+
+ /**
+ * @brief Sets the render notification trigger to call when render thread is completed a frame
+ *
+ * @param renderNotification to use
+ */
+ void SetRenderNotification( TriggerEventInterface* renderNotification );
+
+ /**
+ */
+ virtual tbm_surface_h GetDrawable();
+
+ /**
+ * @brief GetSurface
+ *
+ * @return pixmap
+ */
+ virtual Any GetSurface();
+
+ virtual void ReleaseNativeSource();
+
+public: // from Dali::RenderSurface
+
+ /**
+ * @copydoc Dali::RenderSurface::InitializeEgl()
+ */
+ virtual void InitializeEgl( EglInterface& egl );
+
+ /**
+ * @copydoc Dali::RenderSurface::CreateEglSurface()
+ */
+ virtual void CreateEglSurface( EglInterface& egl );
+
+ /**
+ * @copydoc Dali::RenderSurface::DestroyEglSurface()
+ */
+ virtual void DestroyEglSurface( EglInterface& egl );
+
+ /**
+ * @copydoc Dali::RenderSurface::ReplaceEGLSurface()
+ */
+ virtual bool ReplaceEGLSurface( EglInterface& egl );
+
+ /**
+ * @copydoc Dali::RenderSurface::StartRender()
+ */
+ virtual void StartRender();
+
+ /**
+ * @copydoc Dali::RenderSurface::PreRender()
+ */
+ virtual bool PreRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction );
+
+ /**
+ * @copydoc Dali::RenderSurface::PostRender()
+ */
+ virtual void PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface );
+
+ /**
+ * @copydoc Dali::RenderSurface::StopRender()
+ */
+ virtual void StopRender();
+
+ /**
+ * @copydoc Dali::RenderSurface::SetThreadSynchronization
+ */
+ virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization );
+
+ virtual RenderSurface::Type GetSurfaceType();
+
+ virtual PositionSize GetPositionSize() const;
+
+ virtual void MoveResize( Dali::PositionSize positionSize );
+
+ virtual void SetViewMode( ViewMode viewMode );
+
+private:
+
+ /**
+ * Release any locks.
+ */
+ void ReleaseLock();
+
+ /**
+ * Create XPixmap
+ */
+ virtual void CreateWlRenderable();
+
+private: // Data
+
+ struct Impl;
+
+ Impl* mImpl;
+
+};
+
+} // namespace Dali
+
+#endif // __DALI_TIZEN_BUFFER_RENDER_SURFACE_H__
*/
virtual void ReleaseLock() = 0;
+ /**
+ * @copydoc Dali::RenderSurface::GetSurfaceType()
+ */
+ virtual RenderSurface::Type GetSurfaceType();
+
private:
/**
*/
virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization );
+ virtual RenderSurface::Type GetSurfaceType();
+
private:
/**
# mobile profile internal files
adaptor_common_internal_mobile_profile_src_files = \
$(adaptor_mobile_dir)/accessibility-adaptor-impl-mobile.cpp \
- $(adaptor_mobile_dir)/pixmap-render-surface-factory.cpp \
$(adaptor_mobile_dir)/mobile-system-settings.cpp \
$(adaptor_mobile_dir)/mobile-color-controller-impl.cpp
+
+adaptor_common_internal_wayland_mobile_profile_src_files = \
+ $(adaptor_mobile_dir)/native-source-render-surface-factory.cpp
+
+adaptor_common_internal_x_mobile_profile_src_files = \
+ $(adaptor_mobile_dir)/pixmap-render-surface-factory.cpp
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <native-source-render-surface.h>
+
+namespace Dali
+{
+
+DALI_EXPORT_API NativeSourceRenderSurface* CreateNativeSourceSurface(
+ PositionSize positionSize,
+ const std::string& name,
+ bool isTransparent)
+{
+ return new NativeSourceRenderSurface( positionSize, name, isTransparent );
+}
+
+} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ */
+
+// CLASS HEADER
+#include <display-connection-impl.h>
+
+// EXTERNAL_HEADERS
+#include <tbm_bufmgr.h>
+#include <dali/integration-api/debug.h>
+
+// INTERNAL HEADERS
+#include <native-source-render-surface.h>
+#include <gl/egl-implementation.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+EGLNativeDisplayType DisplayConnection::GetNativeSourceDisplay()
+{
+ return (EGLNativeDisplayType)tbm_bufmgr_init( -1 );
+}
+
+void DisplayConnection::ReleaseNativeSourceDisplay()
+{
+ if( mDisplay )
+ {
+ tbm_bufmgr_deinit( (tbm_bufmgr)mDisplay );
+ }
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+} // namespace Dali
$(adaptor_tizen_dir)/gl/egl-image-extensions-tizen.cpp
adaptor_tizen_internal_native_image_src_files = \
+ $(adaptor_tizen_dir)/display-connection-impl-tizen.cpp \
+ $(adaptor_tizen_dir)/native-source-render-surface-tizen.cpp \
$(adaptor_tizen_dir)/native-image-source-impl-tizen.cpp
public_api_adaptor_tizen_header_files = \
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ *
+ */
+
+// CLASS HEADER
+#include <native-source-render-surface.h>
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/gl-abstraction.h>
+#include <dali/integration-api/debug.h>
+#include <dali/devel-api/threading/conditional-wait.h>
+
+#include <Ecore_Wayland.h>
+#include <tbm_bufmgr.h>
+#include <tbm_surface_queue.h>
+
+// INTERNAL INCLUDES
+#include <trigger-event.h>
+#include <gl/egl-implementation.h>
+#include <base/display-connection.h>
+#include <integration-api/thread-synchronization-interface.h>
+
+namespace Dali
+{
+
+#if defined(DEBUG_ENABLED)
+extern Debug::Filter* gRenderSurfaceLogFilter;
+#endif
+
+struct NativeSourceRenderSurface::Impl
+{
+ Impl( Dali::PositionSize positionSize, const std::string& name, bool isTransparent )
+ : mPosition( positionSize ),
+ mTitle( name ),
+ mRenderNotification( NULL ),
+ mColorDepth( isTransparent ? COLOR_DEPTH_32 : COLOR_DEPTH_24 ),
+ mTbmFormat( isTransparent ? TBM_FORMAT_ARGB8888 : TBM_FORMAT_RGB888 ),
+ mOwnSurface( false ),
+ mConsumeSurface( NULL ),
+ mThreadSynchronization( NULL )
+ {
+ }
+
+ PositionSize mPosition;
+ std::string mTitle;
+ TriggerEventInterface* mRenderNotification;
+ ColorDepth mColorDepth;
+ tbm_format mTbmFormat;
+ bool mOwnSurface;
+
+ tbm_surface_queue_h mTbmQueue;
+ tbm_surface_h mConsumeSurface;
+ ThreadSynchronizationInterface* mThreadSynchronization; ///< A pointer to the thread-synchronization
+ ConditionalWait mTbmSurfaceCondition;
+};
+
+NativeSourceRenderSurface::NativeSourceRenderSurface(Dali::PositionSize positionSize,
+ const std::string& name,
+ bool isTransparent)
+: mImpl( new Impl( positionSize, name, isTransparent ) )
+{
+ ecore_wl_init(NULL);
+ CreateWlRenderable();
+}
+
+NativeSourceRenderSurface::~NativeSourceRenderSurface()
+{
+ // release the surface if we own one
+ if( mImpl->mOwnSurface )
+ {
+
+ if( mImpl->mConsumeSurface )
+ {
+ tbm_surface_queue_release( mImpl->mTbmQueue, mImpl->mConsumeSurface );
+ mImpl->mConsumeSurface = NULL;
+ }
+
+ if( mImpl->mTbmQueue )
+ {
+ tbm_surface_queue_destroy( mImpl->mTbmQueue );
+ }
+
+ delete mImpl;
+
+ DALI_LOG_INFO( gRenderSurfaceLogFilter, Debug::General, "Own tbm surface queue destroy\n" );
+ }
+}
+
+void NativeSourceRenderSurface::SetRenderNotification( TriggerEventInterface* renderNotification )
+{
+ mImpl->mRenderNotification = renderNotification;
+}
+
+tbm_surface_h NativeSourceRenderSurface::GetDrawable()
+{
+ ConditionalWait::ScopedLock lock( mImpl->mTbmSurfaceCondition );
+
+ return mImpl->mConsumeSurface;
+}
+
+Any NativeSourceRenderSurface::GetSurface()
+{
+ return Any( NULL );
+}
+
+void NativeSourceRenderSurface::InitializeEgl( EglInterface& egl )
+{
+ DALI_LOG_TRACE_METHOD( gRenderSurfaceLogFilter );
+
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
+
+ eglImpl.ChooseConfig( true, mImpl->mColorDepth );
+}
+
+void NativeSourceRenderSurface::CreateEglSurface( EglInterface& egl )
+{
+ DALI_LOG_TRACE_METHOD( gRenderSurfaceLogFilter );
+
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
+
+ eglImpl.CreateSurfaceWindow( (EGLNativeWindowType)mImpl->mTbmQueue, mImpl->mColorDepth );
+}
+
+void NativeSourceRenderSurface::DestroyEglSurface( EglInterface& egl )
+{
+ DALI_LOG_TRACE_METHOD( gRenderSurfaceLogFilter );
+
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
+ eglImpl.DestroySurface();
+}
+
+bool NativeSourceRenderSurface::ReplaceEGLSurface( EglInterface& egl )
+{
+ DALI_LOG_TRACE_METHOD( gRenderSurfaceLogFilter );
+
+ if( mImpl->mConsumeSurface )
+ {
+ tbm_surface_queue_release( mImpl->mTbmQueue, mImpl->mConsumeSurface );
+ mImpl->mConsumeSurface = NULL;
+ }
+
+ if( mImpl->mTbmQueue )
+ {
+ tbm_surface_queue_destroy( mImpl->mTbmQueue );
+ }
+
+ CreateWlRenderable();
+
+ if( !mImpl->mTbmQueue )
+ {
+ return false;
+ }
+
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
+
+ return eglImpl.ReplaceSurfaceWindow( (EGLNativeWindowType)mImpl->mTbmQueue ); // reinterpret_cast does not compile
+}
+
+void NativeSourceRenderSurface::StartRender()
+{
+}
+
+bool NativeSourceRenderSurface::PreRender( EglInterface&, Integration::GlAbstraction& )
+{
+ // nothing to do for pixmaps
+ return true;
+}
+
+void NativeSourceRenderSurface::PostRender( EglInterface& egl, Integration::GlAbstraction& glAbstraction, DisplayConnection* displayConnection, bool replacingSurface )
+{
+ Internal::Adaptor::EglImplementation& eglImpl = static_cast<Internal::Adaptor::EglImplementation&>( egl );
+ eglImpl.SwapBuffers();
+
+ // flush gl instruction queue
+ glAbstraction.Flush();
+
+ {
+ if( tbm_surface_queue_can_acquire( mImpl->mTbmQueue, 1 ) )
+ {
+ if( tbm_surface_queue_acquire( mImpl->mTbmQueue, &mImpl->mConsumeSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
+ {
+ DALI_LOG_ERROR( "Failed aquire consume tbm_surface\n" );
+ return;
+ }
+ }
+ }
+
+ // create damage for client applications which wish to know the update timing
+ if( mImpl->mRenderNotification )
+ {
+ // use notification trigger
+ // Tell the event-thread to render the pixmap
+ mImpl->mRenderNotification->Trigger();
+ }
+ else
+ {
+ // FIXME
+ }
+
+}
+
+void NativeSourceRenderSurface::StopRender()
+{
+ ReleaseLock();
+}
+
+PositionSize NativeSourceRenderSurface::GetPositionSize() const
+{
+ return mImpl->mPosition;
+}
+
+void NativeSourceRenderSurface::MoveResize( Dali::PositionSize positionSize )
+{
+}
+
+void NativeSourceRenderSurface::SetViewMode( ViewMode viewMode )
+{
+}
+
+void NativeSourceRenderSurface::SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization )
+{
+ mImpl->mThreadSynchronization = &threadSynchronization;
+}
+
+RenderSurface::Type NativeSourceRenderSurface::GetSurfaceType()
+{
+ return RenderSurface::NATIVE_SOURCE_RENDER_SURFACE;
+}
+
+void NativeSourceRenderSurface::CreateWlRenderable()
+{
+ // check we're creating one with a valid size
+ DALI_ASSERT_ALWAYS( mImpl->mPosition.width > 0 && mImpl->mPosition.height > 0 && "Pixmap size is invalid" );
+
+ mImpl->mTbmQueue = tbm_surface_queue_create( 3, mImpl->mPosition.width, mImpl->mPosition.height, mImpl->mTbmFormat, TBM_BO_DEFAULT );
+
+ if( mImpl->mTbmQueue )
+ {
+ mImpl->mOwnSurface = true;
+ }
+ else
+ {
+ mImpl->mOwnSurface = false;
+ }
+}
+
+void NativeSourceRenderSurface::ReleaseNativeSource()
+{
+ if( mImpl->mConsumeSurface )
+ {
+ tbm_surface_queue_release( mImpl->mTbmQueue, mImpl->mConsumeSurface );
+ mImpl->mConsumeSurface = NULL;
+ }
+}
+
+void NativeSourceRenderSurface::ReleaseLock()
+{
+ if( mImpl->mThreadSynchronization )
+ {
+ mImpl->mThreadSynchronization->PostRenderComplete();
+ }
+}
+
+} // namespace Dali
return true;
}
+void DisplayConnection::SetSurfaceType( RenderSurface::Type type )
+{
+}
+
void DisplayConnection::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
{
CompositorOutput::GetDpi( dpiHorizontal, dpiVertical);
*/
bool InitializeEgl(EglInterface& egl);
+ void SetSurfaceType( RenderSurface::Type type );
+
public:
/**
protected:
+ EGLNativeDisplayType GetNativeSourceDisplay();
+
+ void ReleaseNativeSourceDisplay();
+
// Undefined
DisplayConnection(const DisplayConnection&);
{
}
-
+RenderSurface::Type RenderSurface::GetSurfaceType()
+{
+ return RenderSurface::WAYLAND_RENDER_SURFACE;
+}
} // namespace Wayland
*/
virtual void SetThreadSynchronization( ThreadSynchronizationInterface& threadSynchronization );
+ /**
+ * @copydoc Dali::RenderSurface::GetSurfaceType()
+ */
+ virtual RenderSurface::Type GetSurfaceType();
+
protected: // Data
Window mWindow;
DisplayConnection::DisplayConnection()
: mDisplay(NULL)
{
- // Because of DDK issue, we need to use separated x display instead of ecore default display
- mDisplay = XOpenDisplay(0);
}
DisplayConnection::~DisplayConnection()
return true;
}
+void DisplayConnection::SetSurfaceType( RenderSurface::Type type )
+{
+ if( type == RenderSurface::ECORE_RENDER_SURFACE )
+ {
+ // Because of DDK issue, we need to use separated x display instead of ecore default display
+ mDisplay = XOpenDisplay(0);
+ }
+}
+
void DisplayConnection::GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical)
{
// calculate DPI
*/
bool InitializeEgl(EglInterface& egl);
+ void SetSurfaceType( RenderSurface::Type type );
+
public:
/**
return surfaceId;
}
+RenderSurface::Type EcoreXRenderSurface::GetSurfaceType()
+{
+ return RenderSurface::ECORE_RENDER_SURFACE;
+}
+
} // namespace ECore
} // namespace Dali
endif # USE_ECORE_WAYLAND
adaptor_internal_src_files += $(adaptor_tizen_internal_egl_extension_src_files) \
- $(adaptor_tizen_internal_native_image_src_files)
+ $(adaptor_tizen_internal_native_image_src_files) \
+ $(adaptor_common_internal_wayland_mobile_profile_src_files)
else
adaptor_internal_src_files += $(adaptor_x11_tizen_internal_src_files) \
- $(adaptor_common_internal_egl_extension_src_files)
+ $(adaptor_common_internal_egl_extension_src_files) \
+ $(adaptor_common_internal_x_mobile_profile_src_files)
endif # WAYLAND
endif # MOBILE_PROFILE
projects / platform / core / uifw / dali-adaptor.git / commitdiff