dali/internal/window-system/common/window-impl.cpp

   1 /*
   2  * Copyright (c) 2021 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 <dali/internal/window-system/common/window-impl.h>
  20
  21 // EXTERNAL HEADERS
  22 #include <dali/devel-api/adaptor-framework/orientation.h>
  23 #include <dali/integration-api/core.h>
  24 #include <dali/integration-api/events/touch-event-integ.h>
  25 #include <dali/public-api/actors/actor.h>
  26 #include <dali/public-api/actors/camera-actor.h>
  27 #include <dali/public-api/actors/layer.h>
  28 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  29 #include <dali/public-api/render-tasks/render-task-list.h>
  30 #include <dali/public-api/render-tasks/render-task.h>
  31 #include <dali/public-api/rendering/frame-buffer.h>
  32 #include <thread>
  33
  34 // INTERNAL HEADERS
  35 #include <dali/devel-api/adaptor-framework/accessibility-impl.h>
  36 #include <dali/integration-api/adaptor-framework/render-surface-interface.h>
  37 #include <dali/internal/graphics/gles/egl-graphics.h>
  38 #include <dali/internal/window-system/common/event-handler.h>
  39 #include <dali/internal/window-system/common/orientation-impl.h>
  40 #include <dali/internal/window-system/common/render-surface-factory.h>
  41 #include <dali/internal/window-system/common/window-base.h>
  42 #include <dali/internal/window-system/common/window-factory.h>
  43 #include <dali/internal/window-system/common/window-render-surface.h>
  44 #include <dali/internal/window-system/common/window-system.h>
  45 #include <dali/internal/window-system/common/window-visibility-observer.h>
  46
  47 namespace Dali
  48 {
  49 namespace Internal
  50 {
  51 namespace Adaptor
  52 {
  53 namespace
  54 {
  55 #if defined(DEBUG_ENABLED)
  56 Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW");
  57 #endif
  58
  59 } // unnamed namespace
  60
  61 Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
  62 {
  63   Any surface;
  64   return Window::New(surface, positionSize, name, className, isTransparent);
  65 }
  66
  67 Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, bool isTransparent)
  68 {
  69   Window* window         = new Window();
  70   window->mIsTransparent = isTransparent;
  71   window->Initialize(surface, positionSize, name, className);
  72   return window;
  73 }
  74
  75 Window::Window()
  76 : mWindowSurface(nullptr),
  77   mWindowBase(),
  78   mIsTransparent(false),
  79   mIsFocusAcceptable(true),
  80   mIconified(false),
  81   mOpaqueState(false),
  82   mType(WindowType::NORMAL),
  83   mParentWindow(NULL),
  84   mPreferredAngle(static_cast<int>(WindowOrientation::NO_ORIENTATION_PREFERENCE)),
  85   mRotationAngle(0),
  86   mWindowWidth(0),
  87   mWindowHeight(0),
  88   mOrientationMode(Internal::Adaptor::Window::OrientationMode::PORTRAIT),
  89   mNativeWindowId(-1),
  90   mDeleteRequestSignal(),
  91   mFocusChangeSignal(),
  92   mResizeSignal(),
  93   mVisibilityChangedSignal(),
  94   mTransitionEffectEventSignal(),
  95   mKeyboardRepeatSettingsChangedSignal()
  96 {
  97 }
  98
  99 Window::~Window()
 100 {
 101   if(mAdaptor)
 102   {
 103     auto bridge      = Accessibility::Bridge::GetCurrentBridge();
 104     auto accessible2 = mScene.GetRootLayer();
 105     auto accessible  = Accessibility::Accessible::Get(accessible2);
 106     bridge->RemoveTopLevelWindow(accessible);
 107
 108     mAdaptor->RemoveWindow(this);
 109   }
 110
 111   if(mEventHandler)
 112   {
 113     mEventHandler->RemoveObserver(*this);
 114   }
 115 }
 116
 117 void Window::Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className)
 118 {
 119   // Create a window render surface
 120   auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
 121   mSurface                  = renderSurfaceFactory->CreateWindowRenderSurface(positionSize, surface, mIsTransparent);
 122   mWindowSurface            = static_cast<WindowRenderSurface*>(mSurface.get());
 123
 124   // Get a window base
 125   mWindowBase = mWindowSurface->GetWindowBase();
 126
 127   // Connect signals
 128   mWindowBase->IconifyChangedSignal().Connect(this, &Window::OnIconifyChanged);
 129   mWindowBase->FocusChangedSignal().Connect(this, &Window::OnFocusChanged);
 130   mWindowBase->DeleteRequestSignal().Connect(this, &Window::OnDeleteRequest);
 131   mWindowBase->TransitionEffectEventSignal().Connect(this, &Window::OnTransitionEffectEvent);
 132   mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect(this, &Window::OnKeyboardRepeatSettingsChanged);
 133   mWindowBase->WindowRedrawRequestSignal().Connect(this, &Window::OnWindowRedrawRequest);
 134   mWindowBase->UpdatePositionSizeSignal().Connect(this, &Window::OnUpdatePositionSize);
 135
 136   mWindowSurface->OutputTransformedSignal().Connect(this, &Window::OnOutputTransformed);
 137
 138   AddAuxiliaryHint("wm.policy.win.user.geometry", "1");
 139
 140   SetClass(name, className);
 141
 142   mOrientation = Orientation::New(this);
 143
 144   // Get OrientationMode
 145   int screenWidth, screenHeight;
 146   WindowSystem::GetScreenSize(screenWidth, screenHeight);
 147   if(screenWidth > screenHeight)
 148   {
 149     mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE;
 150   }
 151   else
 152   {
 153     mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
 154   }
 155   // For Debugging
 156   mNativeWindowId = mWindowBase->GetNativeWindowId();
 157 }
 158
 159 void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
 160 {
 161   mEventHandler = EventHandlerPtr(new EventHandler(mWindowSurface->GetWindowBase(), *mAdaptor));
 162   mEventHandler->AddObserver(*this);
 163
 164   auto bridge     = Accessibility::Bridge::GetCurrentBridge();
 165   auto v          = mScene.GetRootLayer();
 166   auto accessible = Accessibility::Accessible::Get(v, true);
 167   bridge->AddTopLevelWindow(accessible);
 168
 169   // If you call the 'Show' before creating the adaptor, the application cannot know the app resource id.
 170   // The show must be called after the adaptor is initialized.
 171   Show();
 172 }
 173
 174 void Window::OnSurfaceSet(Dali::RenderSurfaceInterface* surface)
 175 {
 176   mWindowSurface = static_cast<WindowRenderSurface*>(surface);
 177 }
 178
 179 void Window::SetClass(std::string name, std::string className)
 180 {
 181   mName      = name;
 182   mClassName = className;
 183   mWindowBase->SetClass(name, className);
 184 }
 185
 186 std::string Window::GetClassName() const
 187 {
 188   return mClassName;
 189 }
 190
 191 void Window::Raise()
 192 {
 193   mWindowBase->Raise();
 194
 195   mSurface->SetFullSwapNextFrame();
 196
 197   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId);
 198 }
 199
 200 void Window::Lower()
 201 {
 202   mWindowBase->Lower();
 203
 204   mSurface->SetFullSwapNextFrame();
 205
 206   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId);
 207 }
 208
 209 void Window::Activate()
 210 {
 211   mWindowBase->Activate();
 212
 213   mSurface->SetFullSwapNextFrame();
 214
 215   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId);
 216 }
 217
 218 uint32_t Window::GetLayerCount() const
 219 {
 220   return mScene.GetLayerCount();
 221 }
 222
 223 Dali::Layer Window::GetLayer(uint32_t depth) const
 224 {
 225   return mScene.GetLayer(depth);
 226 }
 227
 228 Dali::RenderTaskList Window::GetRenderTaskList() const
 229 {
 230   return mScene.GetRenderTaskList();
 231 }
 232
 233 void Window::AddAvailableOrientation(WindowOrientation orientation)
 234 {
 235   if(IsOrientationAvailable(orientation) == false)
 236   {
 237     return;
 238   }
 239
 240   bool found          = false;
 241   int  convertedAngle = ConvertToAngle(orientation);
 242   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), AddAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle);
 243   for(std::size_t i = 0; i < mAvailableAngles.size(); i++)
 244   {
 245     if(mAvailableAngles[i] == convertedAngle)
 246     {
 247       found = true;
 248       break;
 249     }
 250   }
 251
 252   if(!found)
 253   {
 254     mAvailableAngles.push_back(convertedAngle);
 255     SetAvailableAnlges(mAvailableAngles);
 256   }
 257 }
 258
 259 void Window::RemoveAvailableOrientation(WindowOrientation orientation)
 260 {
 261   if(IsOrientationAvailable(orientation) == false)
 262   {
 263     return;
 264   }
 265
 266   int convertedAngle = ConvertToAngle(orientation);
 267   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle);
 268   for(std::vector<int>::iterator iter = mAvailableAngles.begin();
 269       iter != mAvailableAngles.end();
 270       ++iter)
 271   {
 272     if(*iter == convertedAngle)
 273     {
 274       mAvailableAngles.erase(iter);
 275       break;
 276     }
 277   }
 278
 279   SetAvailableAnlges(mAvailableAngles);
 280 }
 281
 282 void Window::SetPreferredOrientation(WindowOrientation orientation)
 283 {
 284   if(orientation < WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::LANDSCAPE_INVERSE)
 285   {
 286     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::CheckOrientation: Invalid input orientation [%d]\n", orientation);
 287     return;
 288   }
 289   mPreferredAngle = ConvertToAngle(orientation);
 290   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle);
 291   mWindowBase->SetPreferredAngle(mPreferredAngle);
 292 }
 293
 294 WindowOrientation Window::GetPreferredOrientation()
 295 {
 296   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle);
 297   WindowOrientation preferredOrientation = ConvertToOrientation(mPreferredAngle);
 298   return preferredOrientation;
 299 }
 300
 301 void Window::SetAvailableAnlges(const std::vector<int>& angles)
 302 {
 303   if(angles.size() > 4)
 304   {
 305     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size());
 306     return;
 307   }
 308
 309   mWindowBase->SetAvailableAnlges(angles);
 310 }
 311
 312 int Window::ConvertToAngle(WindowOrientation orientation)
 313 {
 314   int convertAngle = static_cast<int>(orientation);
 315   if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE)
 316   {
 317     switch(orientation)
 318     {
 319       case WindowOrientation::LANDSCAPE:
 320       {
 321         convertAngle = 0;
 322         break;
 323       }
 324       case WindowOrientation::PORTRAIT:
 325       {
 326         convertAngle = 90;
 327         break;
 328       }
 329       case WindowOrientation::LANDSCAPE_INVERSE:
 330       {
 331         convertAngle = 180;
 332         break;
 333       }
 334       case WindowOrientation::PORTRAIT_INVERSE:
 335       {
 336         convertAngle = 270;
 337         break;
 338       }
 339       case WindowOrientation::NO_ORIENTATION_PREFERENCE:
 340       {
 341         convertAngle = -1;
 342         break;
 343       }
 344     }
 345   }
 346   return convertAngle;
 347 }
 348
 349 WindowOrientation Window::ConvertToOrientation(int angle) const
 350 {
 351   WindowOrientation orientation = static_cast<WindowOrientation>(angle);
 352   if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE)
 353   {
 354     switch(angle)
 355     {
 356       case 0:
 357       {
 358         orientation = WindowOrientation::LANDSCAPE;
 359         break;
 360       }
 361       case 90:
 362       {
 363         orientation = WindowOrientation::PORTRAIT;
 364         break;
 365       }
 366       case 180:
 367       {
 368         orientation = WindowOrientation::LANDSCAPE_INVERSE;
 369         break;
 370       }
 371       case 270:
 372       {
 373         orientation = WindowOrientation::PORTRAIT_INVERSE;
 374         break;
 375       }
 376       case -1:
 377       {
 378         orientation = WindowOrientation::NO_ORIENTATION_PREFERENCE;
 379         break;
 380       }
 381     }
 382   }
 383   return orientation;
 384 }
 385
 386 bool Window::IsOrientationAvailable(WindowOrientation orientation) const
 387 {
 388   if(orientation <= WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::LANDSCAPE_INVERSE)
 389   {
 390     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::IsOrientationAvailable: Invalid input orientation [%d]\n", orientation);
 391     return false;
 392   }
 393   return true;
 394 }
 395
 396 Dali::Any Window::GetNativeHandle() const
 397 {
 398   return mWindowSurface->GetNativeWindow();
 399 }
 400
 401 void Window::SetAcceptFocus(bool accept)
 402 {
 403   mIsFocusAcceptable = accept;
 404
 405   mWindowBase->SetAcceptFocus(accept);
 406 }
 407
 408 bool Window::IsFocusAcceptable() const
 409 {
 410   return mIsFocusAcceptable;
 411 }
 412
 413 void Window::Show()
 414 {
 415   mVisible = true;
 416
 417   mWindowBase->Show();
 418
 419   if(!mIconified)
 420   {
 421     WindowVisibilityObserver* observer(mAdaptor);
 422     observer->OnWindowShown();
 423
 424     Dali::Window handle(this);
 425     mVisibilityChangedSignal.Emit(handle, true);
 426   }
 427
 428   mSurface->SetFullSwapNextFrame();
 429
 430   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 431 }
 432
 433 void Window::Hide()
 434 {
 435   mVisible = false;
 436
 437   mWindowBase->Hide();
 438
 439   if(!mIconified)
 440   {
 441     WindowVisibilityObserver* observer(mAdaptor);
 442     observer->OnWindowHidden();
 443
 444     Dali::Window handle(this);
 445     mVisibilityChangedSignal.Emit(handle, false);
 446   }
 447
 448   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 449 }
 450
 451 bool Window::IsVisible() const
 452 {
 453   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 454   return mVisible && !mIconified;
 455 }
 456
 457 unsigned int Window::GetSupportedAuxiliaryHintCount() const
 458 {
 459   return mWindowBase->GetSupportedAuxiliaryHintCount();
 460 }
 461
 462 std::string Window::GetSupportedAuxiliaryHint(unsigned int index) const
 463 {
 464   return mWindowBase->GetSupportedAuxiliaryHint(index);
 465 }
 466
 467 unsigned int Window::AddAuxiliaryHint(const std::string& hint, const std::string& value)
 468 {
 469   return mWindowBase->AddAuxiliaryHint(hint, value);
 470 }
 471
 472 bool Window::RemoveAuxiliaryHint(unsigned int id)
 473 {
 474   return mWindowBase->RemoveAuxiliaryHint(id);
 475 }
 476
 477 bool Window::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
 478 {
 479   return mWindowBase->SetAuxiliaryHintValue(id, value);
 480 }
 481
 482 std::string Window::GetAuxiliaryHintValue(unsigned int id) const
 483 {
 484   return mWindowBase->GetAuxiliaryHintValue(id);
 485 }
 486
 487 unsigned int Window::GetAuxiliaryHintId(const std::string& hint) const
 488 {
 489   return mWindowBase->GetAuxiliaryHintId(hint);
 490 }
 491
 492 void Window::SetInputRegion(const Rect<int>& inputRegion)
 493 {
 494   mWindowBase->SetInputRegion(inputRegion);
 495
 496   DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetInputRegion: x = %d, y = %d, w = %d, h = %d\n", inputRegion.x, inputRegion.y, inputRegion.width, inputRegion.height);
 497 }
 498
 499 void Window::SetType(WindowType type)
 500 {
 501   if(type != mType)
 502   {
 503     mWindowBase->SetType(type);
 504
 505     mType = type;
 506   }
 507 }
 508
 509 WindowType Window::GetType() const
 510 {
 511   return mType;
 512 }
 513
 514 WindowOperationResult Window::SetNotificationLevel(WindowNotificationLevel level)
 515 {
 516   if(mType != WindowType::NOTIFICATION)
 517   {
 518     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", mType);
 519     return WindowOperationResult::INVALID_OPERATION;
 520   }
 521
 522   return mWindowBase->SetNotificationLevel(level);
 523 }
 524
 525 WindowNotificationLevel Window::GetNotificationLevel() const
 526 {
 527   if(mType != WindowType::NOTIFICATION)
 528   {
 529     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", mType);
 530     return WindowNotificationLevel::NONE;
 531   }
 532
 533   return mWindowBase->GetNotificationLevel();
 534 }
 535
 536 void Window::SetOpaqueState(bool opaque)
 537 {
 538   mOpaqueState = opaque;
 539
 540   mWindowBase->SetOpaqueState(opaque);
 541
 542   DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque);
 543 }
 544
 545 bool Window::IsOpaqueState() const
 546 {
 547   return mOpaqueState;
 548 }
 549
 550 WindowOperationResult Window::SetScreenOffMode(WindowScreenOffMode screenOffMode)
 551 {
 552   return mWindowBase->SetScreenOffMode(screenOffMode);
 553 }
 554
 555 WindowScreenOffMode Window::GetScreenOffMode() const
 556 {
 557   return mWindowBase->GetScreenOffMode();
 558 }
 559
 560 WindowOperationResult Window::SetBrightness(int brightness)
 561 {
 562   if(brightness < 0 || brightness > 100)
 563   {
 564     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness);
 565     return WindowOperationResult::INVALID_OPERATION;
 566   }
 567
 568   return mWindowBase->SetBrightness(brightness);
 569 }
 570
 571 int Window::GetBrightness() const
 572 {
 573   return mWindowBase->GetBrightness();
 574 }
 575
 576 void Window::SetSize(Dali::Window::WindowSize size)
 577 {
 578   PositionSize oldRect = mSurface->GetPositionSize();
 579
 580   mWindowSurface->MoveResize(PositionSize(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
 581
 582   PositionSize newRect = mSurface->GetPositionSize();
 583
 584   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
 585   if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
 586   {
 587     Uint16Pair newSize(newRect.width, newRect.height);
 588
 589     SurfaceResized();
 590
 591     mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
 592
 593     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height);
 594
 595     Dali::Window handle(this);
 596     mResizeSignal.Emit(handle, newSize);
 597
 598     mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
 599   }
 600
 601   mSurface->SetFullSwapNextFrame();
 602
 603   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
 604 }
 605
 606 Dali::Window::WindowSize Window::GetSize() const
 607 {
 608   PositionSize positionSize = mSurface->GetPositionSize();
 609
 610   return Dali::Window::WindowSize(positionSize.width, positionSize.height);
 611 }
 612
 613 void Window::SetPosition(Dali::Window::WindowPosition position)
 614 {
 615   PositionSize oldRect = mSurface->GetPositionSize();
 616
 617   mWindowSurface->MoveResize(PositionSize(position.GetX(), position.GetY(), oldRect.width, oldRect.height));
 618
 619   mSurface->SetFullSwapNextFrame();
 620
 621   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(position.GetX(), position.GetY(), oldRect.width, oldRect.height));
 622 }
 623
 624 Dali::Window::WindowPosition Window::GetPosition() const
 625 {
 626   PositionSize positionSize = mSurface->GetPositionSize();
 627
 628   return Dali::Window::WindowPosition(positionSize.x, positionSize.y);
 629 }
 630
 631 void Window::SetPositionSize(PositionSize positionSize)
 632 {
 633   PositionSize oldRect = mSurface->GetPositionSize();
 634
 635   mWindowSurface->MoveResize(positionSize);
 636
 637   PositionSize newRect = mSurface->GetPositionSize();
 638
 639   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
 640   if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
 641   {
 642     Uint16Pair newSize(newRect.width, newRect.height);
 643
 644     SurfaceResized();
 645
 646     mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
 647
 648     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height);
 649     Dali::Window handle(this);
 650     mResizeSignal.Emit(handle, newSize);
 651     mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
 652   }
 653
 654   mSurface->SetFullSwapNextFrame();
 655
 656   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer(), true)->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height));
 657 }
 658
 659 PositionSize Window::GetPositionSize() const
 660 {
 661   return mSurface->GetPositionSize();
 662 }
 663
 664 Dali::Layer Window::GetRootLayer() const
 665 {
 666   return mScene.GetRootLayer();
 667 }
 668
 669 void Window::SetTransparency(bool transparent)
 670 {
 671   mWindowSurface->SetTransparency(transparent);
 672 }
 673
 674 bool Window::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
 675 {
 676   return mWindowBase->GrabKey(key, grabMode);
 677 }
 678
 679 bool Window::UngrabKey(Dali::KEY key)
 680 {
 681   return mWindowBase->UngrabKey(key);
 682 }
 683
 684 bool Window::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
 685 {
 686   return mWindowBase->GrabKeyList(key, grabMode, result);
 687 }
 688
 689 bool Window::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
 690 {
 691   return mWindowBase->UngrabKeyList(key, result);
 692 }
 693
 694 void Window::OnIconifyChanged(bool iconified)
 695 {
 696   if(iconified)
 697   {
 698     mIconified = true;
 699
 700     if(mVisible)
 701     {
 702       WindowVisibilityObserver* observer(mAdaptor);
 703       observer->OnWindowHidden();
 704
 705       Dali::Window handle(this);
 706       mVisibilityChangedSignal.Emit(handle, false);
 707     }
 708
 709     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible);
 710   }
 711   else
 712   {
 713     mIconified = false;
 714
 715     if(mVisible)
 716     {
 717       WindowVisibilityObserver* observer(mAdaptor);
 718       observer->OnWindowShown();
 719
 720       Dali::Window handle(this);
 721       mVisibilityChangedSignal.Emit(handle, true);
 722     }
 723
 724     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible);
 725   }
 726
 727   mSurface->SetFullSwapNextFrame();
 728 }
 729
 730 void Window::OnFocusChanged(bool focusIn)
 731 {
 732   Dali::Window handle(this);
 733   mFocusChangeSignal.Emit(handle, focusIn);
 734
 735   mSurface->SetFullSwapNextFrame();
 736
 737   if(auto b = Dali::Accessibility::Bridge::GetCurrentBridge())
 738   {
 739     if(focusIn)
 740     {
 741       b->ApplicationShown();
 742     }
 743     else
 744     {
 745       b->ApplicationHidden();
 746     }
 747   }
 748 }
 749
 750 void Window::OnOutputTransformed()
 751 {
 752   PositionSize positionSize = mSurface->GetPositionSize();
 753
 754   int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
 755   SurfaceRotated(static_cast<float>(positionSize.width), static_cast<float>(positionSize.height), orientation);
 756
 757   mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
 758   mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
 759 }
 760
 761 void Window::OnDeleteRequest()
 762 {
 763   mDeleteRequestSignal.Emit();
 764 }
 765
 766 void Window::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
 767 {
 768   Dali::Window handle(this);
 769   mTransitionEffectEventSignal.Emit(handle, state, type);
 770 }
 771
 772 void Window::OnKeyboardRepeatSettingsChanged()
 773 {
 774   Dali::Window handle(this);
 775   mKeyboardRepeatSettingsChangedSignal.Emit();
 776 }
 777
 778 void Window::OnWindowRedrawRequest()
 779 {
 780   mAdaptor->RenderOnce();
 781 }
 782
 783 void Window::OnUpdatePositionSize(Dali::PositionSize& positionSize)
 784 {
 785   SetPositionSize(positionSize);
 786 }
 787
 788 void Window::OnTouchPoint(Dali::Integration::Point& point, int timeStamp)
 789 {
 790   FeedTouchPoint(point, timeStamp);
 791 }
 792
 793 void Window::OnWheelEvent(Dali::Integration::WheelEvent& wheelEvent)
 794 {
 795   FeedWheelEvent(wheelEvent);
 796 }
 797
 798 void Window::OnKeyEvent(Dali::Integration::KeyEvent& keyEvent)
 799 {
 800   FeedKeyEvent(keyEvent);
 801 }
 802
 803 void Window::OnRotation(const RotationEvent& rotation)
 804 {
 805   mRotationAngle = rotation.angle;
 806   mWindowWidth   = rotation.width;
 807   mWindowHeight  = rotation.height;
 808
 809   // Notify that the orientation is changed
 810   mOrientation->OnOrientationChange(rotation);
 811
 812   mWindowSurface->RequestRotation(mRotationAngle, mWindowWidth, mWindowHeight);
 813
 814   int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
 815   SurfaceRotated(mWindowWidth, mWindowHeight, orientation);
 816
 817   mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
 818
 819   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), OnRotation(): resize signal emit [%d x %d]\n", this, mNativeWindowId, mWindowWidth, mWindowHeight);
 820   // Emit signal
 821   Dali::Window handle(this);
 822   mResizeSignal.Emit(handle, Dali::Window::WindowSize(mWindowWidth, mWindowHeight));
 823
 824   mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
 825 }
 826
 827 void Window::OnPause()
 828 {
 829   if(mEventHandler)
 830   {
 831     mEventHandler->Pause();
 832   }
 833 }
 834
 835 void Window::OnResume()
 836 {
 837   if(mEventHandler)
 838   {
 839     mEventHandler->Resume();
 840   }
 841
 842   mSurface->SetFullSwapNextFrame();
 843 }
 844
 845 void Window::RecalculateTouchPosition(Integration::Point& point)
 846 {
 847   Vector2 position = point.GetScreenPosition();
 848   Vector2 convertedPosition;
 849
 850   switch(mRotationAngle)
 851   {
 852     case 90:
 853     {
 854       convertedPosition.x = static_cast<float>(mWindowWidth) - position.y;
 855       convertedPosition.y = position.x;
 856       break;
 857     }
 858     case 180:
 859     {
 860       convertedPosition.x = static_cast<float>(mWindowWidth) - position.x;
 861       convertedPosition.y = static_cast<float>(mWindowHeight) - position.y;
 862       break;
 863     }
 864     case 270:
 865     {
 866       convertedPosition.x = position.y;
 867       convertedPosition.y = static_cast<float>(mWindowHeight) - position.x;
 868       break;
 869     }
 870     default:
 871     {
 872       convertedPosition = position;
 873       break;
 874     }
 875   }
 876
 877   point.SetScreenPosition(convertedPosition);
 878 }
 879
 880 Dali::Window Window::Get(Dali::Actor actor)
 881 {
 882   Internal::Adaptor::Window* windowImpl = nullptr;
 883
 884   if(Internal::Adaptor::Adaptor::IsAvailable())
 885   {
 886     Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation(Internal::Adaptor::Adaptor::Get());
 887     windowImpl                                = dynamic_cast<Internal::Adaptor::Window*>(adaptor.GetWindow(actor));
 888     if(windowImpl)
 889     {
 890       return Dali::Window(windowImpl);
 891     }
 892   }
 893
 894   return Dali::Window();
 895 }
 896
 897 void Window::SetParent(Dali::Window& parent)
 898 {
 899   if(DALI_UNLIKELY(parent))
 900   {
 901     mParentWindow     = parent;
 902     Dali::Window self = Dali::Window(this);
 903     // check circular parent window setting
 904     if(Dali::DevelWindow::GetParent(parent) == self)
 905     {
 906       Dali::DevelWindow::Unparent(parent);
 907     }
 908     mWindowBase->SetParent(GetImplementation(mParentWindow).mWindowBase);
 909   }
 910 }
 911
 912 void Window::Unparent()
 913 {
 914   mWindowBase->SetParent(nullptr);
 915   mParentWindow.Reset();
 916 }
 917
 918 Dali::Window Window::GetParent()
 919 {
 920   return mParentWindow;
 921 }
 922
 923 WindowOrientation Window::GetCurrentOrientation() const
 924 {
 925   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle);
 926   return ConvertToOrientation(mRotationAngle);
 927 }
 928
 929 int Window::GetPhysicalOrientation() const
 930 {
 931   return (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
 932 }
 933
 934 void Window::SetAvailableOrientations(const Dali::Vector<WindowOrientation>& orientations)
 935 {
 936   Dali::Vector<float>::SizeType count = orientations.Count();
 937   for(Dali::Vector<float>::SizeType index = 0; index < count; ++index)
 938   {
 939     if(IsOrientationAvailable(orientations[index]) == false)
 940     {
 941       DALI_LOG_ERROR("Window::SetAvailableOrientations, invalid orientation: %d\n", orientations[index]);
 942       continue;
 943     }
 944
 945     bool found          = false;
 946     int  convertedAngle = ConvertToAngle(orientations[index]);
 947
 948     for(std::size_t i = 0; i < mAvailableAngles.size(); i++)
 949     {
 950       if(mAvailableAngles[i] == convertedAngle)
 951       {
 952         found = true;
 953         break;
 954       }
 955     }
 956
 957     if(!found)
 958     {
 959       DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetAvailableOrientations: %d\n", this, mNativeWindowId, convertedAngle);
 960       mAvailableAngles.push_back(convertedAngle);
 961     }
 962   }
 963   SetAvailableAnlges(mAvailableAngles);
 964 }
 965
 966 int32_t Window::GetNativeId() const
 967 {
 968   return mWindowBase->GetNativeWindowId();
 969 }
 970
 971 } // namespace Adaptor
 972
 973 } // namespace Internal
 974
 975 } // namespace Dali