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

   1 /*
   2  * Copyright (c) 2022 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/devel-api/events/key-event-devel.h>
  24 #include <dali/integration-api/core.h>
  25 #include <dali/integration-api/events/touch-event-integ.h>
  26 #include <dali/integration-api/events/touch-integ.h>
  27 #include <dali/public-api/actors/actor.h>
  28 #include <dali/public-api/actors/camera-actor.h>
  29 #include <dali/public-api/actors/layer.h>
  30 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  31 #include <dali/public-api/render-tasks/render-task-list.h>
  32 #include <dali/public-api/render-tasks/render-task.h>
  33 #include <dali/public-api/rendering/frame-buffer.h>
  34 #include <thread>
  35
  36 // INTERNAL HEADERS
  37 #include <dali/devel-api/adaptor-framework/accessibility-bridge.h>
  38 #include <dali/devel-api/atspi-interfaces/accessible.h>
  39 #include <dali/integration-api/adaptor-framework/render-surface-interface.h>
  40 #include <dali/internal/graphics/gles/egl-graphics.h>
  41 #include <dali/internal/window-system/common/event-handler.h>
  42 #include <dali/internal/window-system/common/orientation-impl.h>
  43 #include <dali/internal/window-system/common/render-surface-factory.h>
  44 #include <dali/internal/window-system/common/window-base.h>
  45 #include <dali/internal/window-system/common/window-factory.h>
  46 #include <dali/internal/window-system/common/window-render-surface.h>
  47 #include <dali/internal/window-system/common/window-system.h>
  48 #include <dali/internal/window-system/common/window-visibility-observer.h>
  49
  50 namespace Dali
  51 {
  52 namespace Internal
  53 {
  54 namespace Adaptor
  55 {
  56 namespace
  57 {
  58 #if defined(DEBUG_ENABLED)
  59 Debug::Filter* gWindowLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_WINDOW");
  60 #endif
  61
  62 } // unnamed namespace
  63
  64 Window* Window::New(const PositionSize& positionSize, const std::string& name, const std::string& className, Dali::WindowType type, bool isTransparent)
  65 {
  66   Any surface;
  67   return Window::New(surface, positionSize, name, className, type, isTransparent);
  68 }
  69
  70 Window* Window::New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, Dali::WindowType type, bool isTransparent)
  71 {
  72   Window* window         = new Window();
  73   window->mIsTransparent = isTransparent;
  74   window->Initialize(surface, positionSize, name, className, type);
  75   return window;
  76 }
  77
  78 Window::Window()
  79 : mWindowSurface(nullptr),
  80   mWindowBase(),
  81   mParentWindow(NULL),
  82   mPreferredAngle(static_cast<int>(WindowOrientation::NO_ORIENTATION_PREFERENCE)),
  83   mRotationAngle(0),
  84   mWindowWidth(0),
  85   mWindowHeight(0),
  86   mNativeWindowId(-1),
  87   mOrientationMode(Internal::Adaptor::Window::OrientationMode::PORTRAIT),
  88   mDeleteRequestSignal(),
  89   mFocusChangeSignal(),
  90   mResizeSignal(),
  91   mVisibilityChangedSignal(),
  92   mTransitionEffectEventSignal(),
  93   mKeyboardRepeatSettingsChangedSignal(),
  94   mAuxiliaryMessageSignal(),
  95   mMovedSignal(),
  96   mLastKeyEvent(),
  97   mLastTouchEvent(),
  98   mIsTransparent(false),
  99   mIsFocusAcceptable(true),
 100   mIconified(false),
 101   mOpaqueState(false),
 102   mWindowRotationAcknowledgement(false),
 103   mFocused(false)
 104 {
 105 }
 106
 107 Window::~Window()
 108 {
 109   if(mScene)
 110   {
 111     auto bridge     = Accessibility::Bridge::GetCurrentBridge();
 112     auto rootLayer  = mScene.GetRootLayer();
 113     auto accessible = Accessibility::Accessible::Get(rootLayer);
 114     bridge->RemoveTopLevelWindow(accessible);
 115     // Related to multi-window case. This is called for default window and non-default window, but it is effective for non-default window.
 116     bridge->Emit(accessible, Accessibility::WindowEvent::DESTROY);
 117   }
 118
 119   if(mAdaptor)
 120   {
 121     mAdaptor->RemoveWindow(this);
 122   }
 123
 124   if(mEventHandler)
 125   {
 126     mEventHandler->RemoveObserver(*this);
 127   }
 128 }
 129
 130 void Window::Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, WindowType type)
 131 {
 132   // Create a window render surface
 133   auto renderSurfaceFactory = Dali::Internal::Adaptor::GetRenderSurfaceFactory();
 134   mSurface                  = renderSurfaceFactory->CreateWindowRenderSurface(positionSize, surface, mIsTransparent);
 135   mWindowSurface            = static_cast<WindowRenderSurface*>(mSurface.get());
 136
 137   // Get a window base
 138   mWindowBase = mWindowSurface->GetWindowBase();
 139
 140   // Set Window Type
 141   mWindowBase->SetType(type);
 142
 143   // Initialize for Ime window type
 144   if(type == WindowType::IME)
 145   {
 146     mWindowBase->InitializeIme();
 147     mWindowSurface->InitializeImeSurface();
 148   }
 149
 150   // Connect signals
 151   mWindowBase->IconifyChangedSignal().Connect(this, &Window::OnIconifyChanged);
 152   mWindowBase->FocusChangedSignal().Connect(this, &Window::OnFocusChanged);
 153   mWindowBase->DeleteRequestSignal().Connect(this, &Window::OnDeleteRequest);
 154   mWindowBase->TransitionEffectEventSignal().Connect(this, &Window::OnTransitionEffectEvent);
 155   mWindowBase->KeyboardRepeatSettingsChangedSignal().Connect(this, &Window::OnKeyboardRepeatSettingsChanged);
 156   mWindowBase->WindowRedrawRequestSignal().Connect(this, &Window::OnWindowRedrawRequest);
 157   mWindowBase->UpdatePositionSizeSignal().Connect(this, &Window::OnUpdatePositionSize);
 158   mWindowBase->AuxiliaryMessageSignal().Connect(this, &Window::OnAuxiliaryMessage);
 159
 160   mWindowSurface->OutputTransformedSignal().Connect(this, &Window::OnOutputTransformed);
 161
 162   AddAuxiliaryHint("wm.policy.win.user.geometry", "1");
 163
 164   SetClass(name, className);
 165
 166   mOrientation = Orientation::New(this);
 167
 168   // Get OrientationMode
 169   int screenWidth, screenHeight;
 170   WindowSystem::GetScreenSize(screenWidth, screenHeight);
 171   if(screenWidth > screenHeight)
 172   {
 173     mOrientationMode = Internal::Adaptor::Window::OrientationMode::LANDSCAPE;
 174   }
 175   else
 176   {
 177     mOrientationMode = Internal::Adaptor::Window::OrientationMode::PORTRAIT;
 178   }
 179   // For Debugging
 180   mNativeWindowId = mWindowBase->GetNativeWindowId();
 181 }
 182
 183 void Window::OnAdaptorSet(Dali::Adaptor& adaptor)
 184 {
 185   mEventHandler = EventHandlerPtr(new EventHandler(mWindowSurface->GetWindowBase(), *mAdaptor));
 186   mEventHandler->AddObserver(*this);
 187
 188   // Add Window to bridge for ATSPI
 189   auto bridge = Accessibility::Bridge::GetCurrentBridge();
 190   if(bridge->IsUp())
 191   {
 192     auto rootLayer  = mScene.GetRootLayer();
 193     auto accessible = Accessibility::Accessible::Get(rootLayer);
 194     bridge->AddTopLevelWindow(accessible);
 195   }
 196
 197   bridge->EnabledSignal().Connect(this, &Window::OnAccessibilityEnabled);
 198   bridge->DisabledSignal().Connect(this, &Window::OnAccessibilityDisabled);
 199
 200   // If you call the 'Show' before creating the adaptor, the application cannot know the app resource id.
 201   // The show must be called after the adaptor is initialized.
 202   Show();
 203 }
 204
 205 void Window::OnSurfaceSet(Dali::RenderSurfaceInterface* surface)
 206 {
 207   mWindowSurface = static_cast<WindowRenderSurface*>(surface);
 208 }
 209
 210 void Window::SetClass(std::string name, std::string className)
 211 {
 212   mName      = name;
 213   mClassName = className;
 214   mWindowBase->SetClass(name, className);
 215 }
 216
 217 std::string Window::GetClassName() const
 218 {
 219   return mClassName;
 220 }
 221
 222 void Window::Raise()
 223 {
 224   mWindowBase->Raise();
 225
 226   mSurface->SetFullSwapNextFrame();
 227
 228   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Raise() \n", this, mNativeWindowId);
 229 }
 230
 231 void Window::Lower()
 232 {
 233   mWindowBase->Lower();
 234
 235   mSurface->SetFullSwapNextFrame();
 236
 237   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Lower() \n", this, mNativeWindowId);
 238 }
 239
 240 void Window::Activate()
 241 {
 242   mWindowBase->Activate();
 243
 244   mSurface->SetFullSwapNextFrame();
 245
 246   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Activate() \n", this, mNativeWindowId);
 247 }
 248
 249 void Window::Maximize(bool maximize)
 250 {
 251   mWindowBase->Maximize(maximize);
 252
 253   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Maximize: %d\n", this, mNativeWindowId, maximize);
 254 }
 255
 256 bool Window::IsMaximized() const
 257 {
 258   return mWindowBase->IsMaximized();
 259 }
 260
 261 void Window::SetMaximumSize(Dali::Window::WindowSize size)
 262 {
 263   mWindowBase->SetMaximumSize(size);
 264 }
 265
 266 void Window::Minimize(bool minimize)
 267 {
 268   mWindowBase->Minimize(minimize);
 269
 270   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Minimize: %d\n", this, mNativeWindowId, minimize);
 271 }
 272
 273 bool Window::IsMinimized() const
 274 {
 275   return mWindowBase->IsMinimized();
 276 }
 277
 278 void Window::SetMimimumSize(Dali::Window::WindowSize size)
 279 {
 280   mWindowBase->SetMimimumSize(size);
 281 }
 282
 283 uint32_t Window::GetLayerCount() const
 284 {
 285   return mScene.GetLayerCount();
 286 }
 287
 288 Dali::Layer Window::GetLayer(uint32_t depth) const
 289 {
 290   return mScene.GetLayer(depth);
 291 }
 292
 293 Dali::RenderTaskList Window::GetRenderTaskList() const
 294 {
 295   return mScene.GetRenderTaskList();
 296 }
 297
 298 std::string Window::GetNativeResourceId() const
 299 {
 300   return mWindowBase->GetNativeWindowResourceId();
 301 }
 302
 303 void Window::AddAvailableOrientation(WindowOrientation orientation)
 304 {
 305   if(IsOrientationAvailable(orientation) == false)
 306   {
 307     return;
 308   }
 309
 310   bool found          = false;
 311   int  convertedAngle = ConvertToAngle(orientation);
 312   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), AddAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle);
 313   for(std::size_t i = 0; i < mAvailableAngles.size(); i++)
 314   {
 315     if(mAvailableAngles[i] == convertedAngle)
 316     {
 317       found = true;
 318       break;
 319     }
 320   }
 321
 322   if(!found)
 323   {
 324     mAvailableAngles.push_back(convertedAngle);
 325     SetAvailableAnlges(mAvailableAngles);
 326   }
 327 }
 328
 329 void Window::RemoveAvailableOrientation(WindowOrientation orientation)
 330 {
 331   if(IsOrientationAvailable(orientation) == false)
 332   {
 333     return;
 334   }
 335
 336   int convertedAngle = ConvertToAngle(orientation);
 337   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), RemoveAvailableOrientation: %d\n", this, mNativeWindowId, convertedAngle);
 338   for(std::vector<int>::iterator iter = mAvailableAngles.begin();
 339       iter != mAvailableAngles.end();
 340       ++iter)
 341   {
 342     if(*iter == convertedAngle)
 343     {
 344       mAvailableAngles.erase(iter);
 345       break;
 346     }
 347   }
 348
 349   SetAvailableAnlges(mAvailableAngles);
 350 }
 351
 352 void Window::SetPreferredOrientation(WindowOrientation orientation)
 353 {
 354   if(orientation < WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::LANDSCAPE_INVERSE)
 355   {
 356     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::CheckOrientation: Invalid input orientation [%d]\n", orientation);
 357     return;
 358   }
 359   mPreferredAngle = ConvertToAngle(orientation);
 360   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle);
 361   mWindowBase->SetPreferredAngle(mPreferredAngle);
 362 }
 363
 364 WindowOrientation Window::GetPreferredOrientation()
 365 {
 366   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetPreferredOrientation: %d\n", this, mNativeWindowId, mPreferredAngle);
 367   WindowOrientation preferredOrientation = ConvertToOrientation(mPreferredAngle);
 368   return preferredOrientation;
 369 }
 370
 371 void Window::SetPositionSizeWithOrientation(PositionSize positionSize, WindowOrientation orientation)
 372 {
 373   int angle = ConvertToAngle(orientation);
 374   mWindowBase->SetPositionSizeWithAngle(positionSize, angle);
 375 }
 376
 377 void Window::EmitAccessibilityHighlightSignal(bool highlight)
 378 {
 379   Dali::Window handle(this);
 380   mAccessibilityHighlightSignal.Emit(handle, highlight);
 381 }
 382
 383 void Window::SetAvailableAnlges(const std::vector<int>& angles)
 384 {
 385   if(angles.size() > 4)
 386   {
 387     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetAvailableAnlges: Invalid vector size! [%d]\n", angles.size());
 388     return;
 389   }
 390
 391   mWindowBase->SetAvailableAnlges(angles);
 392 }
 393
 394 int Window::ConvertToAngle(WindowOrientation orientation)
 395 {
 396   int convertAngle = static_cast<int>(orientation);
 397   if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE)
 398   {
 399     switch(orientation)
 400     {
 401       case WindowOrientation::LANDSCAPE:
 402       {
 403         convertAngle = 0;
 404         break;
 405       }
 406       case WindowOrientation::PORTRAIT:
 407       {
 408         convertAngle = 90;
 409         break;
 410       }
 411       case WindowOrientation::LANDSCAPE_INVERSE:
 412       {
 413         convertAngle = 180;
 414         break;
 415       }
 416       case WindowOrientation::PORTRAIT_INVERSE:
 417       {
 418         convertAngle = 270;
 419         break;
 420       }
 421       case WindowOrientation::NO_ORIENTATION_PREFERENCE:
 422       {
 423         convertAngle = -1;
 424         break;
 425       }
 426     }
 427   }
 428   return convertAngle;
 429 }
 430
 431 WindowOrientation Window::ConvertToOrientation(int angle) const
 432 {
 433   WindowOrientation orientation = static_cast<WindowOrientation>(angle);
 434   if(mOrientationMode == Internal::Adaptor::Window::OrientationMode::LANDSCAPE)
 435   {
 436     switch(angle)
 437     {
 438       case 0:
 439       {
 440         orientation = WindowOrientation::LANDSCAPE;
 441         break;
 442       }
 443       case 90:
 444       {
 445         orientation = WindowOrientation::PORTRAIT;
 446         break;
 447       }
 448       case 180:
 449       {
 450         orientation = WindowOrientation::LANDSCAPE_INVERSE;
 451         break;
 452       }
 453       case 270:
 454       {
 455         orientation = WindowOrientation::PORTRAIT_INVERSE;
 456         break;
 457       }
 458       case -1:
 459       {
 460         orientation = WindowOrientation::NO_ORIENTATION_PREFERENCE;
 461         break;
 462       }
 463     }
 464   }
 465   return orientation;
 466 }
 467
 468 bool Window::IsOrientationAvailable(WindowOrientation orientation) const
 469 {
 470   if(orientation <= WindowOrientation::NO_ORIENTATION_PREFERENCE || orientation > WindowOrientation::LANDSCAPE_INVERSE)
 471   {
 472     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::IsOrientationAvailable: Invalid input orientation [%d]\n", orientation);
 473     return false;
 474   }
 475   return true;
 476 }
 477
 478 Dali::Any Window::GetNativeHandle() const
 479 {
 480   return mWindowSurface->GetNativeWindow();
 481 }
 482
 483 void Window::SetAcceptFocus(bool accept)
 484 {
 485   mIsFocusAcceptable = accept;
 486
 487   mWindowBase->SetAcceptFocus(accept);
 488 }
 489
 490 bool Window::IsFocusAcceptable() const
 491 {
 492   return mIsFocusAcceptable;
 493 }
 494
 495 void Window::Show()
 496 {
 497   mVisible = true;
 498
 499   mWindowBase->Show();
 500
 501   if(!mIconified)
 502   {
 503     Dali::Window handle(this);
 504     mVisibilityChangedSignal.Emit(handle, true);
 505     Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown(handle);
 506
 507     WindowVisibilityObserver* observer(mAdaptor);
 508     observer->OnWindowShown();
 509   }
 510
 511   mSurface->SetFullSwapNextFrame();
 512
 513   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Show(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 514 }
 515
 516 void Window::Hide()
 517 {
 518   mVisible = false;
 519
 520   mWindowBase->Hide();
 521
 522   if(!mIconified)
 523   {
 524     Dali::Window handle(this);
 525     mVisibilityChangedSignal.Emit(handle, false);
 526     Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(handle);
 527
 528     WindowVisibilityObserver* observer(mAdaptor);
 529     observer->OnWindowHidden();
 530   }
 531
 532   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Hide(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 533 }
 534
 535 bool Window::IsVisible() const
 536 {
 537   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), IsVisible(): iconified = %d, visible = %d\n", this, mNativeWindowId, mIconified, mVisible);
 538   return mVisible && !mIconified;
 539 }
 540
 541 unsigned int Window::GetSupportedAuxiliaryHintCount() const
 542 {
 543   return mWindowBase->GetSupportedAuxiliaryHintCount();
 544 }
 545
 546 std::string Window::GetSupportedAuxiliaryHint(unsigned int index) const
 547 {
 548   return mWindowBase->GetSupportedAuxiliaryHint(index);
 549 }
 550
 551 unsigned int Window::AddAuxiliaryHint(const std::string& hint, const std::string& value)
 552 {
 553   return mWindowBase->AddAuxiliaryHint(hint, value);
 554 }
 555
 556 bool Window::RemoveAuxiliaryHint(unsigned int id)
 557 {
 558   return mWindowBase->RemoveAuxiliaryHint(id);
 559 }
 560
 561 bool Window::SetAuxiliaryHintValue(unsigned int id, const std::string& value)
 562 {
 563   return mWindowBase->SetAuxiliaryHintValue(id, value);
 564 }
 565
 566 std::string Window::GetAuxiliaryHintValue(unsigned int id) const
 567 {
 568   return mWindowBase->GetAuxiliaryHintValue(id);
 569 }
 570
 571 unsigned int Window::GetAuxiliaryHintId(const std::string& hint) const
 572 {
 573   return mWindowBase->GetAuxiliaryHintId(hint);
 574 }
 575
 576 void Window::SetInputRegion(const Rect<int>& inputRegion)
 577 {
 578   Rect<int> convertRegion = RecalculateRect(inputRegion);
 579
 580   DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window (%p), WinId (%d), SetInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height);
 581
 582   mWindowBase->SetInputRegion(convertRegion);
 583 }
 584
 585 void Window::SetType(WindowType type)
 586 {
 587   mWindowBase->SetType(type);
 588 }
 589
 590 WindowType Window::GetType() const
 591 {
 592   return mWindowBase->GetType();
 593 }
 594
 595 WindowOperationResult Window::SetNotificationLevel(WindowNotificationLevel level)
 596 {
 597   WindowType type = mWindowBase->GetType();
 598   if(type != WindowType::NOTIFICATION)
 599   {
 600     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetNotificationLevel: Not supported window type [%d]\n", type);
 601     return WindowOperationResult::INVALID_OPERATION;
 602   }
 603
 604   return mWindowBase->SetNotificationLevel(level);
 605 }
 606
 607 WindowNotificationLevel Window::GetNotificationLevel() const
 608 {
 609   WindowType type = mWindowBase->GetType();
 610   if(type != WindowType::NOTIFICATION)
 611   {
 612     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::GetNotificationLevel: Not supported window type [%d]\n", type);
 613     return WindowNotificationLevel::NONE;
 614   }
 615
 616   return mWindowBase->GetNotificationLevel();
 617 }
 618
 619 void Window::SetOpaqueState(bool opaque)
 620 {
 621   mOpaqueState = opaque;
 622
 623   mWindowBase->SetOpaqueState(opaque);
 624
 625   DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetOpaqueState: opaque = %d\n", opaque);
 626 }
 627
 628 bool Window::IsOpaqueState() const
 629 {
 630   return mOpaqueState;
 631 }
 632
 633 WindowOperationResult Window::SetScreenOffMode(WindowScreenOffMode screenOffMode)
 634 {
 635   return mWindowBase->SetScreenOffMode(screenOffMode);
 636 }
 637
 638 WindowScreenOffMode Window::GetScreenOffMode() const
 639 {
 640   return mWindowBase->GetScreenOffMode();
 641 }
 642
 643 WindowOperationResult Window::SetBrightness(int brightness)
 644 {
 645   if(brightness < 0 || brightness > 100)
 646   {
 647     DALI_LOG_INFO(gWindowLogFilter, Debug::Verbose, "Window::SetBrightness: Invalid brightness value [%d]\n", brightness);
 648     return WindowOperationResult::INVALID_OPERATION;
 649   }
 650
 651   return mWindowBase->SetBrightness(brightness);
 652 }
 653
 654 int Window::GetBrightness() const
 655 {
 656   return mWindowBase->GetBrightness();
 657 }
 658
 659 void Window::SetSize(Dali::Window::WindowSize size)
 660 {
 661   PositionSize oldRect = mSurface->GetPositionSize();
 662
 663   mWindowSurface->MoveResize(PositionSize(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
 664
 665   PositionSize newRect = mSurface->GetPositionSize();
 666
 667   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
 668   if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
 669   {
 670     Uint16Pair newSize(newRect.width, newRect.height);
 671
 672     mWindowWidth  = newRect.width;
 673     mWindowHeight = newRect.height;
 674
 675     SurfaceResized();
 676
 677     mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
 678
 679     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetSize(): resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.width, newRect.height);
 680
 681     Dali::Window handle(this);
 682     mResizeSignal.Emit(handle, newSize);
 683
 684     mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
 685   }
 686
 687   mSurface->SetFullSwapNextFrame();
 688
 689   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer())->EmitBoundsChanged(Dali::Rect<>(oldRect.x, oldRect.y, size.GetWidth(), size.GetHeight()));
 690 }
 691
 692 Dali::Window::WindowSize Window::GetSize() const
 693 {
 694   PositionSize positionSize = mSurface->GetPositionSize();
 695
 696   return Dali::Window::WindowSize(positionSize.width, positionSize.height);
 697 }
 698
 699 void Window::SetPosition(Dali::Window::WindowPosition position)
 700 {
 701   PositionSize oldRect = mSurface->GetPositionSize();
 702
 703   mWindowSurface->MoveResize(PositionSize(position.GetX(), position.GetY(), oldRect.width, oldRect.height));
 704
 705   mSurface->SetFullSwapNextFrame();
 706
 707   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer())->EmitBoundsChanged(Dali::Rect<>(position.GetX(), position.GetY(), oldRect.width, oldRect.height));
 708 }
 709
 710 Dali::Window::WindowPosition Window::GetPosition() const
 711 {
 712   PositionSize positionSize = mSurface->GetPositionSize();
 713
 714   return Dali::Window::WindowPosition(positionSize.x, positionSize.y);
 715 }
 716
 717 PositionSize Window::GetPositionSize() const
 718 {
 719   return mSurface->GetPositionSize();
 720 }
 721
 722 void Window::SetPositionSize(PositionSize positionSize)
 723 {
 724   PositionSize oldRect = mSurface->GetPositionSize();
 725   Dali::Window handle(this);
 726
 727   mWindowSurface->MoveResize(positionSize);
 728
 729   PositionSize newRect = mSurface->GetPositionSize();
 730
 731   if((oldRect.x != newRect.x) || (oldRect.y != newRect.y))
 732   {
 733     Dali::Window::WindowPosition position(newRect.x, newRect.y);
 734     mMovedSignal.Emit(handle, position);
 735   }
 736
 737   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
 738   if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
 739   {
 740     Uint16Pair newSize(newRect.width, newRect.height);
 741
 742     mWindowWidth  = newRect.width;
 743     mWindowHeight = newRect.height;
 744
 745     SurfaceResized();
 746
 747     mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
 748
 749     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), current angle (%d), SetPositionSize():resize signal [%d x %d]\n", this, mNativeWindowId, mRotationAngle, newRect.width, newRect.height);
 750     mResizeSignal.Emit(handle, newSize);
 751     mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
 752   }
 753
 754   mSurface->SetFullSwapNextFrame();
 755
 756   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer())->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height));
 757 }
 758
 759 Dali::Layer Window::GetRootLayer() const
 760 {
 761   return mScene.GetRootLayer();
 762 }
 763
 764 void Window::SetTransparency(bool transparent)
 765 {
 766   mWindowSurface->SetTransparency(transparent);
 767 }
 768
 769 bool Window::GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode)
 770 {
 771   return mWindowBase->GrabKey(key, grabMode);
 772 }
 773
 774 bool Window::UngrabKey(Dali::KEY key)
 775 {
 776   return mWindowBase->UngrabKey(key);
 777 }
 778
 779 bool Window::GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result)
 780 {
 781   return mWindowBase->GrabKeyList(key, grabMode, result);
 782 }
 783
 784 bool Window::UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result)
 785 {
 786   return mWindowBase->UngrabKeyList(key, result);
 787 }
 788
 789 void Window::OnIconifyChanged(bool iconified)
 790 {
 791   if(iconified)
 792   {
 793     mIconified = true;
 794
 795     if(mVisible)
 796     {
 797       Dali::Window handle(this);
 798       mVisibilityChangedSignal.Emit(handle, false);
 799       Dali::Accessibility::Bridge::GetCurrentBridge()->WindowHidden(handle);
 800
 801       WindowVisibilityObserver* observer(mAdaptor);
 802       observer->OnWindowHidden();
 803     }
 804
 805     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Iconified: visible = %d\n", this, mNativeWindowId, mVisible);
 806   }
 807   else
 808   {
 809     mIconified = false;
 810
 811     if(mVisible)
 812     {
 813       Dali::Window handle(this);
 814       mVisibilityChangedSignal.Emit(handle, true);
 815       Dali::Accessibility::Bridge::GetCurrentBridge()->WindowShown(handle);
 816
 817       WindowVisibilityObserver* observer(mAdaptor);
 818       observer->OnWindowShown();
 819     }
 820
 821     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Deiconified: visible = %d\n", this, mNativeWindowId, mVisible);
 822   }
 823
 824   mSurface->SetFullSwapNextFrame();
 825 }
 826
 827 void Window::OnFocusChanged(bool focusIn)
 828 {
 829   Dali::Window handle(this);
 830   mFocusChangeSignal.Emit(handle, focusIn);
 831
 832   mSurface->SetFullSwapNextFrame();
 833
 834   if(auto bridge = Dali::Accessibility::Bridge::GetCurrentBridge())
 835   {
 836     if(focusIn)
 837     {
 838       bridge->WindowFocused(handle);
 839     }
 840     else
 841     {
 842       bridge->WindowUnfocused(handle);
 843     }
 844   }
 845   mFocused = focusIn;
 846 }
 847
 848 void Window::OnOutputTransformed()
 849 {
 850   PositionSize positionSize = mSurface->GetPositionSize();
 851
 852   int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
 853   SurfaceRotated(static_cast<float>(positionSize.width), static_cast<float>(positionSize.height), orientation);
 854
 855   mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
 856   mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(positionSize.width, positionSize.height));
 857 }
 858
 859 void Window::OnDeleteRequest()
 860 {
 861   mDeleteRequestSignal.Emit();
 862 }
 863
 864 void Window::OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type)
 865 {
 866   Dali::Window handle(this);
 867   mTransitionEffectEventSignal.Emit(handle, state, type);
 868 }
 869
 870 void Window::OnKeyboardRepeatSettingsChanged()
 871 {
 872   Dali::Window handle(this);
 873   mKeyboardRepeatSettingsChangedSignal.Emit();
 874 }
 875
 876 void Window::OnWindowRedrawRequest()
 877 {
 878   mAdaptor->RenderOnce();
 879 }
 880
 881 void Window::OnUpdatePositionSize(Dali::PositionSize& positionSize)
 882 {
 883   bool resized = false;
 884   bool moved = false;
 885   Dali::Window handle(this);
 886   PositionSize oldRect = mSurface->GetPositionSize();
 887
 888   mWindowSurface->UpdatePositionSize(positionSize);
 889
 890   PositionSize newRect = positionSize;
 891
 892   if((oldRect.x != newRect.x) || (oldRect.y != newRect.y))
 893   {
 894     moved = true;
 895   }
 896
 897   if((oldRect.width != newRect.width) || (oldRect.height != newRect.height))
 898   {
 899     resized = true;
 900   }
 901
 902   if(moved)
 903   {
 904     Dali::Window::WindowPosition position(newRect.x, newRect.y);
 905     mMovedSignal.Emit(handle, position);
 906   }
 907
 908   // When surface size is updated, inform adaptor of resizing and emit ResizeSignal
 909   if(resized)
 910   {
 911     Uint16Pair newSize(newRect.width, newRect.height);
 912
 913     mWindowWidth   = newRect.width;
 914     mWindowHeight  = newRect.height;
 915
 916     SurfaceResized();
 917
 918     mAdaptor->SurfaceResizePrepare(mSurface.get(), newSize);
 919
 920     DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), Updated PositionSize by server :resize signal [%d x %d]\n", this, mNativeWindowId, newRect.width, newRect.height);
 921     mResizeSignal.Emit(handle, newSize);
 922     mAdaptor->SurfaceResizeComplete(mSurface.get(), newSize);
 923   }
 924
 925   mSurface->SetFullSwapNextFrame();
 926
 927   Dali::Accessibility::Accessible::Get(mScene.GetRootLayer())->EmitBoundsChanged(Dali::Rect<>(positionSize.x, positionSize.y, positionSize.width, positionSize.height));
 928 }
 929
 930 void Window::OnTouchPoint(Dali::Integration::Point& point, int timeStamp)
 931 {
 932   mLastTouchEvent = Dali::Integration::NewTouchEvent(timeStamp, point);
 933   FeedTouchPoint(point, timeStamp);
 934 }
 935
 936 void Window::OnWheelEvent(Dali::Integration::WheelEvent& wheelEvent)
 937 {
 938   FeedWheelEvent(wheelEvent);
 939 }
 940
 941 void Window::OnKeyEvent(Dali::Integration::KeyEvent& keyEvent)
 942 {
 943   mLastKeyEvent = Dali::DevelKeyEvent::New(keyEvent.keyName, keyEvent.logicalKey, keyEvent.keyString, keyEvent.keyCode, keyEvent.keyModifier, keyEvent.time, static_cast<Dali::KeyEvent::State>(keyEvent.state), keyEvent.compose, keyEvent.deviceName, keyEvent.deviceClass, keyEvent.deviceSubclass);
 944   FeedKeyEvent(keyEvent);
 945 }
 946
 947 void Window::OnRotation(const RotationEvent& rotation)
 948 {
 949   PositionSize newPositionSize(rotation.x, rotation.y, rotation.width, rotation.height);
 950
 951   mRotationAngle = rotation.angle;
 952   mWindowWidth   = rotation.width;
 953   mWindowHeight  = rotation.height;
 954
 955   // Notify that the orientation is changed
 956   mOrientation->OnOrientationChange(rotation);
 957
 958   mWindowSurface->RequestRotation(mRotationAngle, newPositionSize);
 959
 960   int orientation = (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
 961   SurfaceRotated(mWindowWidth, mWindowHeight, orientation);
 962
 963   mAdaptor->SurfaceResizePrepare(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
 964
 965   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), OnRotation(): x[%d], y[%d], resize signal emit [%d x %d]\n", this, mNativeWindowId, newPositionSize.x, newPositionSize.y, mWindowWidth, mWindowHeight);
 966   // Emit signal
 967   Dali::Window handle(this);
 968   mResizeSignal.Emit(handle, Dali::Window::WindowSize(mWindowWidth, mWindowHeight));
 969
 970   mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
 971 }
 972
 973 void Window::OnPause()
 974 {
 975   if(mEventHandler)
 976   {
 977     mEventHandler->Pause();
 978   }
 979 }
 980
 981 void Window::OnResume()
 982 {
 983   if(mEventHandler)
 984   {
 985     mEventHandler->Resume();
 986   }
 987
 988   mSurface->SetFullSwapNextFrame();
 989 }
 990
 991 void Window::OnAuxiliaryMessage(const std::string& key, const std::string& value, const Property::Array& options)
 992 {
 993   mAuxiliaryMessageSignal.Emit(key, value, options);
 994 }
 995
 996 void Window::OnAccessibilityEnabled()
 997 {
 998   auto bridge     = Accessibility::Bridge::GetCurrentBridge();
 999   auto rootLayer  = mScene.GetRootLayer();
1000   auto accessible = Accessibility::Accessible::Get(rootLayer);
1001   bridge->AddTopLevelWindow(accessible);
1002
1003   if(!mVisible || mIconified)
1004   {
1005     return;
1006   }
1007
1008   Dali::Window handle(this);
1009   bridge->WindowShown(handle);
1010
1011   if(mFocused)
1012   {
1013     bridge->WindowFocused(handle);
1014   }
1015 }
1016
1017 void Window::OnAccessibilityDisabled()
1018 {
1019   auto bridge     = Accessibility::Bridge::GetCurrentBridge();
1020   auto rootLayer  = mScene.GetRootLayer();
1021   auto accessible = Accessibility::Accessible::Get(rootLayer);
1022   bridge->RemoveTopLevelWindow(accessible);
1023 }
1024
1025 void Window::RecalculateTouchPosition(Integration::Point& point)
1026 {
1027   Vector2 position = point.GetScreenPosition();
1028   Vector2 convertedPosition;
1029
1030   switch(mRotationAngle)
1031   {
1032     case 90:
1033     {
1034       convertedPosition.x = static_cast<float>(mWindowWidth) - position.y;
1035       convertedPosition.y = position.x;
1036       break;
1037     }
1038     case 180:
1039     {
1040       convertedPosition.x = static_cast<float>(mWindowWidth) - position.x;
1041       convertedPosition.y = static_cast<float>(mWindowHeight) - position.y;
1042       break;
1043     }
1044     case 270:
1045     {
1046       convertedPosition.x = position.y;
1047       convertedPosition.y = static_cast<float>(mWindowHeight) - position.x;
1048       break;
1049     }
1050     default:
1051     {
1052       convertedPosition = position;
1053       break;
1054     }
1055   }
1056
1057   point.SetScreenPosition(convertedPosition);
1058 }
1059
1060 Dali::Window Window::Get(Dali::Actor actor)
1061 {
1062   Internal::Adaptor::Window* windowImpl = nullptr;
1063
1064   if(Internal::Adaptor::Adaptor::IsAvailable())
1065   {
1066     Dali::Internal::Adaptor::Adaptor& adaptor = Internal::Adaptor::Adaptor::GetImplementation(Internal::Adaptor::Adaptor::Get());
1067     windowImpl                                = dynamic_cast<Internal::Adaptor::Window*>(adaptor.GetWindow(actor));
1068     if(windowImpl)
1069     {
1070       return Dali::Window(windowImpl);
1071     }
1072   }
1073
1074   return Dali::Window();
1075 }
1076
1077 void Window::SetParent(Dali::Window& parent)
1078 {
1079   if(DALI_UNLIKELY(parent))
1080   {
1081     mParentWindow     = parent;
1082     Dali::Window self = Dali::Window(this);
1083     // check circular parent window setting
1084     if(Dali::DevelWindow::GetParent(parent) == self)
1085     {
1086       Dali::DevelWindow::Unparent(parent);
1087     }
1088     mWindowBase->SetParent(GetImplementation(mParentWindow).mWindowBase, false);
1089   }
1090 }
1091
1092 void Window::SetParent(Dali::Window& parent, bool belowParent)
1093 {
1094   if(DALI_UNLIKELY(parent))
1095   {
1096     mParentWindow     = parent;
1097     Dali::Window self = Dali::Window(this);
1098     // check circular parent window setting
1099     if(Dali::DevelWindow::GetParent(parent) == self)
1100     {
1101       Dali::DevelWindow::Unparent(parent);
1102     }
1103     mWindowBase->SetParent(GetImplementation(mParentWindow).mWindowBase, belowParent);
1104   }
1105 }
1106
1107 void Window::Unparent()
1108 {
1109   mWindowBase->SetParent(nullptr, false);
1110   mParentWindow.Reset();
1111 }
1112
1113 Dali::Window Window::GetParent()
1114 {
1115   return mParentWindow;
1116 }
1117
1118 WindowOrientation Window::GetCurrentOrientation() const
1119 {
1120   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), GetCurrentOrientation(): %d\n", this, mNativeWindowId, mRotationAngle);
1121   return ConvertToOrientation(mRotationAngle);
1122 }
1123
1124 int Window::GetPhysicalOrientation() const
1125 {
1126   return (mRotationAngle + mWindowBase->GetScreenRotationAngle()) % 360;
1127 }
1128
1129 void Window::SetAvailableOrientations(const Dali::Vector<WindowOrientation>& orientations)
1130 {
1131   Dali::Vector<float>::SizeType count = orientations.Count();
1132   for(Dali::Vector<float>::SizeType index = 0; index < count; ++index)
1133   {
1134     if(IsOrientationAvailable(orientations[index]) == false)
1135     {
1136       DALI_LOG_ERROR("Window::SetAvailableOrientations, invalid orientation: %d\n", orientations[index]);
1137       continue;
1138     }
1139
1140     bool found          = false;
1141     int  convertedAngle = ConvertToAngle(orientations[index]);
1142
1143     for(std::size_t i = 0; i < mAvailableAngles.size(); i++)
1144     {
1145       if(mAvailableAngles[i] == convertedAngle)
1146       {
1147         found = true;
1148         break;
1149       }
1150     }
1151
1152     if(!found)
1153     {
1154       DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SetAvailableOrientations: %d\n", this, mNativeWindowId, convertedAngle);
1155       mAvailableAngles.push_back(convertedAngle);
1156     }
1157   }
1158   SetAvailableAnlges(mAvailableAngles);
1159 }
1160
1161 int32_t Window::GetNativeId() const
1162 {
1163   return mWindowBase->GetNativeWindowId();
1164 }
1165
1166 void Window::RequestMoveToServer()
1167 {
1168   mWindowBase->RequestMoveToServer();
1169 }
1170
1171 void Window::RequestResizeToServer(WindowResizeDirection direction)
1172 {
1173   mWindowBase->RequestResizeToServer(direction);
1174 }
1175
1176 void Window::EnableFloatingMode(bool enable)
1177 {
1178   mWindowBase->EnableFloatingMode(enable);
1179 }
1180
1181 Rect<int> Window::RecalculateRect(const Rect<int>& rect)
1182 {
1183   Rect<int> newRect;
1184   int       screenWidth, screenHeight;
1185
1186   WindowSystem::GetScreenSize(screenWidth, screenHeight);
1187
1188   if(mRotationAngle == 90)
1189   {
1190     newRect.x      = rect.y;
1191     newRect.y      = screenHeight - (rect.x + rect.width);
1192     newRect.width  = rect.height;
1193     newRect.height = rect.width;
1194   }
1195   else if(mRotationAngle == 180)
1196   {
1197     newRect.x      = screenWidth - (rect.x + rect.width);
1198     newRect.y      = screenHeight - (rect.y + rect.height);
1199     newRect.width  = rect.width;
1200     newRect.height = rect.height;
1201   }
1202   else if(mRotationAngle == 270)
1203   {
1204     newRect.x      = screenWidth - (rect.y + rect.height);
1205     newRect.y      = rect.x;
1206     newRect.width  = rect.height;
1207     newRect.height = rect.width;
1208   }
1209   else
1210   {
1211     newRect.x      = rect.x;
1212     newRect.y      = rect.y;
1213     newRect.width  = rect.width;
1214     newRect.height = rect.height;
1215   }
1216   return newRect;
1217 }
1218
1219 void Window::IncludeInputRegion(const Rect<int>& inputRegion)
1220 {
1221   Rect<int> convertRegion = RecalculateRect(inputRegion);
1222
1223   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), IncludeInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height);
1224   mWindowBase->IncludeInputRegion(convertRegion);
1225 }
1226
1227 void Window::ExcludeInputRegion(const Rect<int>& inputRegion)
1228 {
1229   Rect<int> convertRegion = RecalculateRect(inputRegion);
1230
1231   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), ExcludeInputRegion, RecalculateRegion, (%d,%d), (%d x %d)\n", this, mNativeWindowId, convertRegion.x, convertRegion.y, convertRegion.width, convertRegion.height);
1232   mWindowBase->ExcludeInputRegion(convertRegion);
1233 }
1234
1235 void Window::SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement)
1236 {
1237   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), needAcknowledgement(%d) Set needs Rotation Completed Acknowledgement\n", this, mNativeWindowId, needAcknowledgement);
1238   mWindowSurface->SetNeedsRotationCompletedAcknowledgement(needAcknowledgement);
1239   mWindowRotationAcknowledgement = needAcknowledgement;
1240 }
1241
1242 void Window::SendRotationCompletedAcknowledgement()
1243 {
1244   DALI_LOG_RELEASE_INFO("Window (%p), WinId (%d), SendRotationCompletedAcknowledgement(): orientation: %d, mWindowRotationAcknowledgement: %d\n", this, mNativeWindowId, mRotationAngle, mWindowRotationAcknowledgement);
1245   if(mWindowRotationAcknowledgement)
1246   {
1247     SetRotationCompletedAcknowledgement();
1248   }
1249 }
1250
1251 bool Window::IsWindowRotating() const
1252 {
1253   return mWindowSurface->IsWindowRotating();
1254 }
1255
1256 const Dali::KeyEvent& Window::GetLastKeyEvent() const
1257 {
1258   return mLastKeyEvent;
1259 }
1260
1261 const Dali::TouchEvent& Window::GetLastTouchEvent() const
1262 {
1263   return mLastTouchEvent;
1264 }
1265
1266 } // namespace Adaptor
1267
1268 } // namespace Internal
1269
1270 } // namespace Dali