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