adaptors/wayland/window-impl-wl.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "window-impl.h"
  20
  21 // EXTERNAL HEADERS
  22 #include <dali/integration-api/core.h>
  23 #include <dali/integration-api/system-overlay.h>
  24 #include <dali/public-api/render-tasks/render-task.h>
  25 #include <dali/public-api/render-tasks/render-task-list.h>
  26 #include <orientation.h>
  27
  28 // INTERNAL HEADERS
  29 #include "render-surface/render-surface-wl.h"
  30 #include <drag-and-drop-detector-impl.h>
  31 #include <window-visibility-observer.h>
  32 #include <orientation-impl.h>
  33
  34
  35
  36 namespace Dali
  37 {
  38 namespace Internal
  39 {
  40 namespace Adaptor
  41 {
  42 #if defined(DEBUG_ENABLED)
  43 Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::Concise, false, "LOG_WINDOW");
  44 #endif
  45
  46 struct Window::EventHandler
  47 {
  48   // place holder
  49 };
  50
  51 Window* Window::New(const PositionSize& posSize, const std::string& name, const std::string& className, bool isTransparent)
  52 {
  53   Window* window = new Window();
  54   window->mIsTransparent = isTransparent;
  55   window->Initialize(posSize, name, className);
  56   return window;
  57 }
  58
  59 void Window::SetAdaptor(Dali::Adaptor& adaptor)
  60 {
  61   DALI_ASSERT_ALWAYS( !mStarted && "Adaptor already started" );
  62   mStarted = true;
  63
  64   // Only create one overlay per window
  65   Internal::Adaptor::Adaptor& adaptorImpl = Internal::Adaptor::Adaptor::GetImplementation(adaptor);
  66   Integration::Core& core = adaptorImpl.GetCore();
  67   mOverlay = &core.GetSystemOverlay();
  68
  69   Dali::RenderTaskList taskList = mOverlay->GetOverlayRenderTasks();
  70   taskList.CreateTask();
  71
  72   mAdaptor = &adaptorImpl;
  73   mAdaptor->AddObserver( *this );
  74
  75   // Can only create the detector when we know the Core has been instantiated.
  76   mDragAndDropDetector = DragAndDropDetector::New();
  77   mAdaptor->SetDragAndDropDetector( &GetImplementation( mDragAndDropDetector ) );
  78
  79
  80 }
  81
  82 RenderSurface* Window::GetSurface()
  83 {
  84   return mSurface;
  85 }
  86
  87 void Window::ShowIndicator( Dali::Window::IndicatorVisibleMode visibleMode )
  88 {
  89
  90 }
  91
  92 void Window::RotateIndicator(Dali::Window::WindowOrientation orientation)
  93 {
  94 }
  95
  96 void Window::SetIndicatorBgOpacity( Dali::Window::IndicatorBgOpacity opacityMode )
  97 {
  98 }
  99
 100 void Window::SetClass(std::string name, std::string klass)
 101 {
 102 }
 103
 104 Window::Window()
 105 : mSurface( NULL ),
 106   mIndicatorVisible( Dali::Window::VISIBLE ),
 107   mIndicatorIsShown( false ),
 108   mShowRotatedIndicatorOnClose( false ),
 109   mStarted( false ),
 110   mIsTransparent( false ),
 111   mWMRotationAppSet( false ),
 112   mIsFocusAcceptable( true ),
 113   mVisible( true ),
 114   mOpaqueState( false ),
 115   mIndicator( NULL ),
 116   mIndicatorOrientation( Dali::Window::PORTRAIT ),
 117   mNextIndicatorOrientation( Dali::Window::PORTRAIT ),
 118   mIndicatorOpacityMode( Dali::Window::OPAQUE ),
 119   mOverlay( NULL ),
 120   mAdaptor( NULL ),
 121   mType( Dali::DevelWindow::NORMAL ),
 122   mPreferredOrientation( Dali::Window::PORTRAIT ),
 123   mSupportedAuxiliaryHints(),
 124   mAuxiliaryHints()
 125 {
 126   mEventHandler = NULL;
 127 }
 128
 129 Window::~Window()
 130 {
 131   delete mEventHandler;
 132
 133   if ( mAdaptor )
 134   {
 135     mAdaptor->RemoveObserver( *this );
 136     mAdaptor->SetDragAndDropDetector( NULL );
 137     mAdaptor = NULL;
 138   }
 139
 140   delete mSurface;
 141 }
 142
 143 void Window::Initialize(const PositionSize& windowPosition, const std::string& name, const std::string& className)
 144 {
 145   // create an Wayland window by default
 146   Any surface;
 147   Wayland::RenderSurface* windowSurface = new Wayland::RenderSurface( windowPosition, surface, name, mIsTransparent );
 148
 149   mSurface = windowSurface;
 150
 151   mOrientation = Orientation::New(this);
 152
 153 }
 154
 155 void Window::DoShowIndicator( Dali::Window::WindowOrientation lastOrientation )
 156 {
 157
 158 }
 159
 160 void Window::DoRotateIndicator( Dali::Window::WindowOrientation orientation )
 161 {
 162
 163 }
 164
 165 void Window::SetIndicatorProperties( bool isShow, Dali::Window::WindowOrientation lastOrientation )
 166 {
 167 }
 168
 169 void Window::IndicatorTypeChanged(IndicatorInterface::Type type)
 170 {
 171 }
 172
 173 void Window::IndicatorClosed( IndicatorInterface* indicator )
 174 {
 175
 176 }
 177
 178 void Window::IndicatorVisibilityChanged(bool isVisible)
 179 {
 180
 181 }
 182
 183 void Window::SetIndicatorActorRotation()
 184 {
 185
 186 }
 187
 188 void Window::Raise()
 189 {
 190 }
 191
 192 void Window::Lower()
 193 {
 194 }
 195
 196 void Window::Activate()
 197 {
 198 }
 199
 200 Dali::DragAndDropDetector Window::GetDragAndDropDetector() const
 201 {
 202   return mDragAndDropDetector;
 203 }
 204
 205 Dali::Any Window::GetNativeHandle() const
 206 {
 207   Wayland::RenderSurface* surface = static_cast<  Wayland::RenderSurface* >( mSurface );
 208
 209   return surface->GetWindow();
 210 }
 211
 212 void Window::OnStart()
 213 {
 214 }
 215
 216 void Window::OnPause()
 217 {
 218 }
 219
 220 void Window::OnResume()
 221 {
 222 }
 223
 224 void Window::OnStop()
 225 {
 226 }
 227
 228 void Window::OnDestroy()
 229 {
 230   mAdaptor = NULL;
 231 }
 232
 233 void Window::AddAvailableOrientation(Dali::Window::WindowOrientation orientation)
 234 {
 235   bool found = false;
 236
 237   for( std::size_t i=0; i<mAvailableOrientations.size(); i++ )
 238   {
 239     if(mAvailableOrientations[i] == orientation)
 240     {
 241       found = true;
 242       break;
 243     }
 244   }
 245
 246   if( ! found )
 247   {
 248     mAvailableOrientations.push_back(orientation);
 249     SetAvailableOrientations( mAvailableOrientations );
 250   }
 251 }
 252
 253 void Window::RemoveAvailableOrientation(Dali::Window::WindowOrientation orientation)
 254 {
 255   for( std::vector<Dali::Window::WindowOrientation>::iterator iter = mAvailableOrientations.begin();
 256        iter != mAvailableOrientations.end(); ++iter )
 257   {
 258     if( *iter == orientation )
 259     {
 260       mAvailableOrientations.erase( iter );
 261       break;
 262     }
 263   }
 264   SetAvailableOrientations( mAvailableOrientations );
 265 }
 266
 267 void Window::SetAvailableOrientations(const std::vector<Dali::Window::WindowOrientation>& orientations)
 268 {
 269   DALI_ASSERT_ALWAYS( mAvailableOrientations.size() <= 4 && "Incorrect number of available orientations" );
 270 }
 271
 272 const std::vector<Dali::Window::WindowOrientation>& Window::GetAvailableOrientations()
 273 {
 274   return mAvailableOrientations;
 275 }
 276
 277 void Window::SetPreferredOrientation(Dali::Window::WindowOrientation orientation)
 278 {
 279   mPreferredOrientation = orientation;
 280 }
 281
 282 Dali::Window::WindowOrientation Window::GetPreferredOrientation()
 283 {
 284   return mPreferredOrientation;
 285 }
 286
 287 void Window::SetAcceptFocus( bool accept )
 288 {
 289   mIsFocusAcceptable = accept;
 290 }
 291
 292 bool Window::IsFocusAcceptable()
 293 {
 294   return mIsFocusAcceptable;
 295 }
 296
 297 void Window::Show()
 298 {
 299   mVisible = true;
 300 }
 301
 302 void Window::Hide()
 303 {
 304   mVisible = false;
 305 }
 306
 307 bool Window::IsVisible() const
 308 {
 309   return mVisible;
 310 }
 311
 312 void Window::RotationDone( int orientation, int width, int height )
 313 {
 314 }
 315
 316 unsigned int Window::GetSupportedAuxiliaryHintCount()
 317 {
 318   return 0;
 319 }
 320
 321 std::string Window::GetSupportedAuxiliaryHint( unsigned int index )
 322 {
 323   return std::string();
 324 }
 325
 326 unsigned int Window::AddAuxiliaryHint( const std::string& hint, const std::string& value )
 327 {
 328   return -1;
 329 }
 330
 331 bool Window::RemoveAuxiliaryHint( unsigned int id )
 332 {
 333   return false;
 334 }
 335
 336 bool Window::SetAuxiliaryHintValue( unsigned int id, const std::string& value )
 337 {
 338   return false;
 339 }
 340
 341 std::string Window::GetAuxiliaryHintValue( unsigned int id ) const
 342 {
 343   return std::string();
 344 }
 345
 346 unsigned int Window::GetAuxiliaryHintId( const std::string& hint ) const
 347 {
 348   return -1;
 349 }
 350
 351 void Window::SetInputRegion( const Rect< int >& inputRegion )
 352 {
 353 }
 354
 355 void Window::SetType( Dali::DevelWindow::Type type )
 356 {
 357   mType = type;
 358 }
 359
 360 Dali::DevelWindow::Type Window::GetType() const
 361 {
 362   return mType;
 363 }
 364
 365 bool Window::SetNotificationLevel( Dali::DevelWindow::NotificationLevel::Type level )
 366 {
 367   return false;
 368 }
 369
 370 Dali::DevelWindow::NotificationLevel::Type Window::GetNotificationLevel()
 371 {
 372   return Dali::DevelWindow::NotificationLevel::NONE;
 373 }
 374
 375 void Window::SetOpaqueState( bool opaque )
 376 {
 377   mOpaqueState = opaque;
 378 }
 379
 380 bool Window::IsOpaqueState()
 381 {
 382   return mOpaqueState;
 383 }
 384
 385 bool Window::SetScreenMode( Dali::DevelWindow::ScreenMode::Type screenMode )
 386 {
 387   return false;
 388 }
 389
 390 Dali::DevelWindow::ScreenMode::Type Window::GetScreenMode()
 391 {
 392   return Dali::DevelWindow::ScreenMode::DEFAULT;
 393 }
 394
 395 bool Window::SetBrightness( int brightness )
 396 {
 397   return false;
 398 }
 399
 400 int Window::GetBrightness()
 401 {
 402   return 0;
 403 }
 404
 405 void* Window::GetNativeWindowHandler()
 406 {
 407   return NULL;
 408 }
 409
 410 } // Adaptor
 411 } // Internal
 412 } // Dali