/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/common/stage.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/devel-api/actors/actor-devel.h>
#include <dali/integration-api/debug.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/context-notifier.h>
#include <window-impl.h>
#include <tizen-logging.h>
+#include <image-loading.h>
+
+#include <locale-utils.h>
using Dali::TextAbstraction::FontClient;
namespace
{
-__thread Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
+thread_local Adaptor* gThreadLocalAdaptor = NULL; // raw thread specific pointer to allow Adaptor::Get
} // unnamed namespace
Dali::Adaptor* Adaptor::New( Any nativeWindow, RenderSurface *surface, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
Dali::Adaptor* Adaptor::New( Dali::Window window, Dali::Configuration::ContextLoss configuration, EnvironmentOptions* environmentOptions )
{
Any winId = window.GetNativeHandle();
-
Window& windowImpl = Dali::GetImplementation(window);
Dali::Adaptor* adaptor = New( winId, windowImpl.GetSurface(), configuration, environmentOptions );
windowImpl.SetAdaptor(*adaptor);
mGLES = new GlImplementation();
}
- mEglFactory = new EglFactory();
+ mEglFactory = new EglFactory( mEnvironmentOptions->GetMultiSamplingLevel() );
EglSyncImplementation* eglSyncImpl = mEglFactory->GetSyncImplementation();
{
Integration::SetPanGestureSmoothingAmount(mEnvironmentOptions->GetPanGestureSmoothingAmount());
}
+
+ // Set max texture size
+ if( mEnvironmentOptions->GetMaxTextureSize() > 0 )
+ {
+ Dali::SetMaxTextureSize( mEnvironmentOptions->GetMaxTextureSize() );
+ }
+
+ SetupSystemInformation();
}
Adaptor::~Adaptor()
// Only resume the adaptor if we are in the suspended state.
if( PAUSED == mState )
{
- // Resume core first
- mCore->Resume();
-
mState = RUNNING;
// Reset the event handler when adaptor resumed
(*iter)->OnResume();
}
- ProcessCoreEvents(); // Ensure any outstanding messages are processed
+ // Resume core so it processes any requests as well
+ mCore->Resume();
- // Ensure our first update includes the processed messages
+ // Do at end to ensure our first update/render after resumption includes the processed messages as well
mThreadController->Resume();
}
}
mEventHandler->FeedKeyEvent( keyEvent );
}
-bool Adaptor::MoveResize( const PositionSize& positionSize )
-{
- PositionSize old = mSurface->GetPositionSize();
-
- // just resize the surface. The driver should automatically resize the egl Surface (untested)
- // EGL Spec says : EGL window surfaces need to be resized when their corresponding native window
- // is resized. Implementations typically use hooks into the OS and native window
- // system to perform this resizing on demand, transparently to the client.
- mSurface->MoveResize( positionSize );
-
- if(old.width != positionSize.width || old.height != positionSize.height)
- {
- SurfaceSizeChanged(positionSize);
- }
-
- return true;
-}
-
-void Adaptor::SurfaceResized( const PositionSize& positionSize )
+void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
{
- PositionSize old = mSurface->GetPositionSize();
+ PositionSize positionSize = surface.GetPositionSize();
- // Called by an application, when it has resized a window outside of Dali.
- // The EGL driver automatically detects X Window resize calls, and resizes
- // the EGL surface for us.
- mSurface->MoveResize( positionSize );
+ // let the core know the surface size has changed
+ mCore->SurfaceResized( positionSize.width, positionSize.height );
- if(old.width != positionSize.width || old.height != positionSize.height)
- {
- SurfaceSizeChanged(positionSize);
- }
-}
+ mResizedSignal.Emit( mAdaptor );
-void Adaptor::ReplaceSurface( Any nativeWindow, RenderSurface& surface )
-{
mNativeWindow = nativeWindow;
mSurface = &surface;
- SurfaceSizeChanged(mSurface->GetPositionSize());
-
- // flush the event queue to give update and render threads chance
+ // flush the event queue to give the update-render thread chance
// to start processing messages for new camera setup etc as soon as possible
ProcessCoreEvents();
return idleAdded;
}
+void Adaptor::RemoveIdle( CallbackBase* callback )
+{
+ mCallbackManager->RemoveIdleCallback( callback );
+}
Dali::Adaptor& Adaptor::Get()
{
return mNativeWindow;
}
+void Adaptor::SetUseRemoteSurface(bool useRemoteSurface)
+{
+ mUseRemoteSurface = useRemoteSurface;
+}
+
void Adaptor::AddObserver( LifeCycleObserver& observer )
{
ObserverContainer::iterator match ( find(mObservers.begin(), mObservers.end(), &observer) );
RequestUpdate();
}
-void Adaptor::SurfaceSizeChanged(const PositionSize& positionSize)
+void Adaptor::SurfaceResizePrepare( Dali::Adaptor::SurfaceSize surfaceSize )
{
// let the core know the surface size has changed
- mCore->SurfaceResized(positionSize.width, positionSize.height);
+ mCore->SurfaceResized( surfaceSize.GetWidth(), surfaceSize.GetHeight() );
mResizedSignal.Emit( mAdaptor );
}
+void Adaptor::SurfaceResizeComplete( Dali::Adaptor::SurfaceSize surfaceSize )
+{
+ // flush the event queue to give the update-render thread chance
+ // to start processing messages for new camera setup etc as soon as possible
+ ProcessCoreEvents();
+
+ // this method blocks until the render thread has completed the resizing.
+ mThreadController->ResizeSurface();
+}
+
void Adaptor::NotifySceneCreated()
{
GetCore().SceneCreated();
// Start thread controller after the scene has been created
mThreadController->Start();
+
+ // process after surface is created (registering to remote surface provider if required)
+ SurfaceInitialized();
}
void Adaptor::NotifyLanguageChanged()
}
}
+void Adaptor::IndicatorSizeChanged(int height)
+{
+ // let the core know the indicator height is changed
+ mCore->SetTopMargin(height);
+}
+
void Adaptor::ProcessCoreEventsFromIdle()
{
ProcessCoreEvents();
Adaptor::Adaptor(Any nativeWindow, Dali::Adaptor& adaptor, RenderSurface* surface, EnvironmentOptions* environmentOptions)
: mResizedSignal(),
mLanguageChangedSignal(),
- mAdaptor(adaptor),
- mState(READY),
- mCore(NULL),
- mThreadController(NULL),
- mVSyncMonitor(NULL),
+ mAdaptor( adaptor ),
+ mState( READY ),
+ mCore( NULL ),
+ mThreadController( NULL ),
+ mVSyncMonitor( NULL ),
mGLES( NULL ),
+ mGlSync( NULL ),
mEglFactory( NULL ),
mNativeWindow( nativeWindow ),
mSurface( surface ),
mEventHandler( NULL ),
mCallbackManager( NULL ),
mNotificationOnIdleInstalled( false ),
- mNotificationTrigger(NULL),
- mGestureManager(NULL),
+ mNotificationTrigger( NULL ),
+ mGestureManager( NULL ),
+ mDaliFeedbackPlugin(),
+ mFeedbackController( NULL ),
+ mTtsPlayers(),
mObservers(),
mDragAndDropDetector(),
- mDeferredRotationObserver(NULL),
+ mDeferredRotationObserver( NULL ),
mEnvironmentOptions( environmentOptions ? environmentOptions : new EnvironmentOptions /* Create the options if not provided */),
- mPerformanceInterface(NULL),
- mObjectProfiler(NULL),
- mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ )
+ mPerformanceInterface( NULL ),
+ mKernelTracer(),
+ mSystemTracer(),
+ mTriggerEventFactory(),
+ mObjectProfiler( NULL ),
+ mSocketFactory(),
+ mEnvironmentOptionsOwned( environmentOptions ? false : true /* If not provided then we own the object */ ),
+ mUseRemoteSurface( false )
{
DALI_ASSERT_ALWAYS( !IsAvailable() && "Cannot create more than one Adaptor per thread" );
gThreadLocalAdaptor = this;
return mCore->GetStereoBase();
}
+void Adaptor::SetRootLayoutDirection( std::string locale )
+{
+ Dali::Stage stage = Dali::Stage::GetCurrent();
+
+ stage.GetRootLayer().SetProperty( DevelActor::Property::LAYOUT_DIRECTION, Internal::Adaptor::Locale::GetLayoutDirection( locale ) );
+}
+
} // namespace Adaptor
} // namespace Internal
projects / platform / core / uifw / dali-adaptor.git / blobdiff