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

   1 #ifndef DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_IMPL_H
   2 #define DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/actors/layer.h>
  23 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  24 #include <dali/public-api/object/base-object.h>
  25 #include <dali/public-api/object/property-array.h>
  26 #include <dali/public-api/object/ref-object.h>
  27 #include <dali/public-api/render-tasks/render-task-list.h>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali/devel-api/adaptor-framework/window-devel.h>
  31 #include <dali/integration-api/adaptor-framework/scene-holder-impl.h>
  32 #include <dali/internal/adaptor/common/adaptor-impl.h>
  33 #include <dali/internal/window-system/common/event-handler.h>
  34 #include <dali/public-api/adaptor-framework/key-grab.h>
  35 #include <dali/public-api/adaptor-framework/window.h>
  36
  37 namespace Dali
  38 {
  39 class Adaptor;
  40 class Actor;
  41 class RenderSurfaceInterface;
  42
  43 namespace Internal
  44 {
  45 namespace Adaptor
  46 {
  47 class Orientation;
  48 class WindowRenderSurface;
  49 class WindowBase;
  50
  51 class Window;
  52 using WindowPtr       = IntrusivePtr<Window>;
  53 using OrientationPtr  = IntrusivePtr<Orientation>;
  54 using EventHandlerPtr = IntrusivePtr<EventHandler>;
  55
  56 /**
  57  * Window provides a surface to render onto with orientation & indicator properties.
  58  */
  59 class Window : public Dali::Internal::Adaptor::SceneHolder, public EventHandler::Observer, public ConnectionTracker
  60 {
  61 public:
  62   typedef Dali::Window::FocusChangeSignalType                        FocusChangeSignalType;
  63   typedef Dali::Window::ResizeSignalType                             ResizeSignalType;
  64   typedef Dali::DevelWindow::VisibilityChangedSignalType             VisibilityChangedSignalType;
  65   typedef Dali::DevelWindow::TransitionEffectEventSignalType         TransitionEffectEventSignalType;
  66   typedef Dali::DevelWindow::KeyboardRepeatSettingsChangedSignalType KeyboardRepeatSettingsChangedSignalType;
  67   typedef Dali::DevelWindow::AuxiliaryMessageSignalType              AuxiliaryMessageSignalType;
  68   typedef Dali::DevelWindow::AccessibilityHighlightSignalType        AccessibilityHighlightSignalType;
  69   typedef Signal<void()>                                             SignalType;
  70
  71   /**
  72    * @brief Create a new Window. This should only be called once by the Application class
  73    * @param[in] positionSize The position and size of the window
  74    * @param[in] name The window title
  75    * @param[in] className The window class name
  76    * @param[in] type Window type.
  77    * @param[in] isTransparent Whether window is transparent
  78    * @return A newly allocated Window
  79    */
  80   static Window* New(const PositionSize& positionSize, const std::string& name, const std::string& className, Dali::WindowType type, bool isTransparent = false);
  81
  82   /**
  83    * @brief Create a new Window. This should only be called once by the Application class
  84    * @param[in] surface The surface used to render on.
  85    * @param[in] positionSize The position and size of the window
  86    * @param[in] name The window title
  87    * @param[in] className The window class name
  88    * @param[in] type Window type.
  89    * @param[in] isTransparent Whether window is transparent
  90    * @return A newly allocated Window
  91    */
  92   static Window* New(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className,  Dali::WindowType type, bool isTransparent = false);
  93
  94   /**
  95    * @copydoc Dali::Window::SetClass()
  96    */
  97   void SetClass(std::string name, std::string className);
  98
  99   /**
 100    * @brief Gets the window class name.
 101    * @return The class of the window
 102    */
 103   std::string GetClassName() const;
 104
 105   /**
 106    * @copydoc Dali::Window::Raise()
 107    */
 108   void Raise();
 109
 110   /**
 111    * @copydoc Dali::Window::Lower()
 112    */
 113   void Lower();
 114
 115   /**
 116    * @copydoc Dali::Window::Activate()
 117    */
 118   void Activate();
 119
 120   /**
 121    * @copydoc Dali::DevelWindow::Maximize()
 122    */
 123   void Maximize(bool maximize);
 124
 125   /**
 126    * @copydoc Dali::DevelWindow::IsMaximized()
 127    */
 128   bool IsMaximized() const;
 129
 130   /**
 131    * @copydoc Dali::DevelWindow::Minimize()
 132    */
 133   void Minimize(bool minimize);
 134
 135   /**
 136    * @copydoc Dali::DevelWindow::IsMinimized()
 137    */
 138   bool IsMinimized() const;
 139
 140   /**
 141    * @copydoc Dali::Window::GetLayerCount()
 142    */
 143   uint32_t GetLayerCount() const;
 144
 145   /**
 146    * @copydoc Dali::Window::GetLayer()
 147    */
 148   Dali::Layer GetLayer(uint32_t depth) const;
 149
 150   /**
 151    * @copydoc Dali::DevelWindow::GetRenderTaskList()
 152    */
 153   Dali::RenderTaskList GetRenderTaskList() const;
 154
 155   /**
 156    * @brief Get window resource ID assigned by window manager
 157    * @return The resource ID of the window
 158    */
 159   std::string GetNativeResourceId() const;
 160
 161   /**
 162    * @copydoc Dali::Window::AddAvailableOrientation()
 163    */
 164   void AddAvailableOrientation(WindowOrientation orientation);
 165
 166   /**
 167    * @copydoc Dali::Window::RemoveAvailableOrientation()
 168    */
 169   void RemoveAvailableOrientation(WindowOrientation orientation);
 170
 171   /**
 172    * @copydoc Dali::Window::SetPreferredOrientation()
 173    */
 174   void SetPreferredOrientation(WindowOrientation orientation);
 175
 176   /**
 177    * @copydoc Dali::Window::GetPreferredOrientation()
 178    */
 179   WindowOrientation GetPreferredOrientation();
 180
 181   /**
 182    * @copydoc Dali::Window::SetAcceptFocus()
 183    */
 184   void SetAcceptFocus(bool accept);
 185
 186   /**
 187    * @copydoc Dali::Window::IsFocusAcceptable()
 188    */
 189   bool IsFocusAcceptable() const;
 190
 191   /**
 192    * @copydoc Dali::Window::Show()
 193    */
 194   void Show();
 195
 196   /**
 197    * @copydoc Dali::Window::Hide()
 198    */
 199   void Hide();
 200
 201   /**
 202    * @copydoc Dali::Window::GetSupportedAuxiliaryHintCount()
 203    */
 204   unsigned int GetSupportedAuxiliaryHintCount() const;
 205
 206   /**
 207    * @copydoc Dali::Window::GetSupportedAuxiliaryHint()
 208    */
 209   std::string GetSupportedAuxiliaryHint(unsigned int index) const;
 210
 211   /**
 212    * @copydoc Dali::Window::AddAuxiliaryHint()
 213    */
 214   unsigned int AddAuxiliaryHint(const std::string& hint, const std::string& value);
 215
 216   /**
 217    * @copydoc Dali::Window::RemoveAuxiliaryHint()
 218    */
 219   bool RemoveAuxiliaryHint(unsigned int id);
 220
 221   /**
 222    * @copydoc Dali::Window::SetAuxiliaryHintValue()
 223    */
 224   bool SetAuxiliaryHintValue(unsigned int id, const std::string& value);
 225
 226   /**
 227    * @copydoc Dali::Window::GetAuxiliaryHintValue()
 228    */
 229   std::string GetAuxiliaryHintValue(unsigned int id) const;
 230
 231   /**
 232    * @copydoc Dali::Window::GetAuxiliaryHintId()
 233    */
 234   unsigned int GetAuxiliaryHintId(const std::string& hint) const;
 235
 236   /**
 237    * @copydoc Dali::Window::SetInputRegion()
 238    */
 239   void SetInputRegion(const Rect<int>& inputRegion);
 240
 241   /**
 242    * @copydoc Dali::Window::SetType()
 243    */
 244   void SetType(WindowType type);
 245
 246   /**
 247    * @copydoc Dali::Window::GetType() const
 248    */
 249   WindowType GetType() const;
 250
 251   /**
 252    * @copydoc Dali::Window::SetNotificationLevel()
 253    */
 254   WindowOperationResult SetNotificationLevel(WindowNotificationLevel level);
 255
 256   /**
 257    * @copydoc Dali::Window::GetNotificationLevel()
 258    */
 259   WindowNotificationLevel GetNotificationLevel() const;
 260
 261   /**
 262    * @copydoc Dali::Window::SetOpaqueState()
 263    */
 264   void SetOpaqueState(bool opaque);
 265
 266   /**
 267    * @copydoc Dali::Window::IsOpaqueState()
 268    */
 269   bool IsOpaqueState() const;
 270
 271   /**
 272    * @copydoc Dali::Window::SetScreenOffMode()
 273    */
 274   WindowOperationResult SetScreenOffMode(WindowScreenOffMode screenOffMode);
 275
 276   /**
 277    * @copydoc Dali::Window::GetScreenOffMode()
 278    */
 279   WindowScreenOffMode GetScreenOffMode() const;
 280
 281   /**
 282    * @copydoc Dali::Window::SetBrightness()
 283    */
 284   WindowOperationResult SetBrightness(int brightness);
 285
 286   /**
 287    * @copydoc Dali::Window::GetBrightness()
 288    */
 289   int GetBrightness() const;
 290
 291   /**
 292    * @copydoc Dali::Window::SetSize()
 293    */
 294   void SetSize(Dali::Window::WindowSize size);
 295
 296   /**
 297    * @copydoc Dali::Window::GetSize()
 298    */
 299   Dali::Window::WindowSize GetSize() const;
 300
 301   /**
 302    * @copydoc Dali::Window::SetPosition()
 303    */
 304   void SetPosition(Dali::Window::WindowPosition position);
 305
 306   /**
 307    * @copydoc Dali::Window::GetPosition()
 308    */
 309   Dali::Window::WindowPosition GetPosition() const;
 310
 311   /**
 312    * @copydoc Dali::DevelWindow::SetPositionSize()
 313    */
 314   void SetPositionSize(PositionSize positionSize);
 315
 316   /**
 317    * @copydoc Dali::DevelWindow::GetPositionSize()
 318    */
 319   PositionSize GetPositionSize() const;
 320
 321   /**
 322    * @copydoc Dali::Window::GetRootLayer()
 323    */
 324   Dali::Layer GetRootLayer() const;
 325
 326   /**
 327    * @copydoc Dali::Window::SetTransparency()
 328    */
 329   void SetTransparency(bool transparent);
 330
 331   /**
 332    * @copydoc Dali::KeyGrab::GrabKey()
 333    */
 334   bool GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode);
 335
 336   /**
 337    * @copydoc Dali::KeyGrab::UngrabKey()
 338    */
 339   bool UngrabKey(Dali::KEY key);
 340
 341   /**
 342    * @copydoc Dali::KeyGrab::GrabKeyList()
 343    */
 344   bool GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result);
 345
 346   /**
 347    * @copydoc Dali::KeyGrab::UngrabKeyList()
 348    */
 349   bool UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result);
 350
 351   /**
 352    * @copydoc Dali::DevelWindow::Get()
 353    */
 354   static Dali::Window Get(Dali::Actor actor);
 355
 356   /**
 357    * @copydoc Dali::DevelWindow::SetParent(Window window, Window parent)
 358    */
 359   void SetParent(Dali::Window& parent);
 360
 361   /**
 362    * @copydoc Dali::DevelWindow::SetParent(Window window, Window parent, bool belowParent)
 363    */
 364   void SetParent(Dali::Window& parent, bool belowParent);
 365
 366   /**
 367    * @copydoc Dali::DevelWindow::Unparent()
 368    */
 369   void Unparent();
 370
 371   /**
 372    * @copydoc Dali::DevelWindow::GetParent()
 373    */
 374   Dali::Window GetParent();
 375
 376   /**
 377    * @copydoc Dali::DevelWindow::GetCurrentOrientation()
 378    */
 379   WindowOrientation GetCurrentOrientation() const;
 380
 381   /**
 382    * @copydoc Dali::DevelWindow::GetPhysicalOrientation()
 383    */
 384   int GetPhysicalOrientation() const;
 385
 386   /**
 387    * @copydoc Dali::DevelWindow::SetAvailableOrientations()
 388    */
 389   void SetAvailableOrientations(const Dali::Vector<WindowOrientation>& orientations);
 390
 391   /**
 392    * @copydoc Dali::DevelWindow::SetPositionSizeWithOrientation()
 393    */
 394   void SetPositionSizeWithOrientation(PositionSize positionSize, WindowOrientation orientation);
 395
 396   /**
 397    * @brief Emit the accessibility highlight signal.
 398    * The highlight indicates that it is an object to interact with the user regardless of focus.
 399    * After setting the highlight on the object, you can do things that the object can do, such as
 400    * giving or losing focus.
 401    *
 402    * @param[in] highlight If window needs to grab or clear highlight.
 403    */
 404   void EmitAccessibilityHighlightSignal(bool highlight);
 405
 406 public: // Dali::Internal::Adaptor::SceneHolder
 407   /**
 408    * @copydoc Dali::Internal::Adaptor::SceneHolder::GetNativeHandle
 409    */
 410   Dali::Any GetNativeHandle() const override;
 411
 412   /**
 413    * @copydoc Dali::Internal::Adaptor::SceneHolder::IsVisible
 414    */
 415   bool IsVisible() const override;
 416
 417   /**
 418    * @copydoc Dali::DevelWindow::GetNativeId()
 419    */
 420   int32_t GetNativeId() const;
 421
 422   /**
 423    * @copydoc Dali::DevelWindow::RequestMoveToServer()
 424    */
 425   void RequestMoveToServer();
 426
 427   /**
 428    * @copydoc Dali::DevelWindow::RequestResizeToServer()
 429    */
 430   void RequestResizeToServer(WindowResizeDirection direction);
 431
 432   /**
 433    * @copydoc Dali::DevelWindow::EnableFloatingMode()
 434    */
 435   void EnableFloatingMode(bool enable);
 436
 437   /**
 438    * @copydoc Dali::DevelWindow::IncludeInputRegion()
 439    */
 440   void IncludeInputRegion(const Rect<int>& inputRegion);
 441
 442   /**
 443    * @copydoc Dali::DevelWindow::ExcludeInputRegion()
 444    */
 445   void ExcludeInputRegion(const Rect<int>& inputRegion);
 446
 447   /**
 448    * @copydoc Dali::DevelWindow::SetNeedsRotationCompletedAcknowledgement()
 449    */
 450   void SetNeedsRotationCompletedAcknowledgement(bool needAcknowledgement);
 451
 452   /**
 453    * @copydoc Dali::DevelWindow::SendRotationCompletedAcknowledgement()
 454    */
 455   void SendRotationCompletedAcknowledgement();
 456
 457   /**
 458    * @copydoc Dali::DevelWindow::IsWindowRotating()
 459    */
 460   bool IsWindowRotating() const;
 461
 462 private:
 463   /**
 464    * @brief Enumeration for orietation mode.
 465    * The Orientation Mode is related to screen size.
 466    * If screen width is longer than height, the Orientation Mode will have LANDSCAPE.
 467    * Otherwise screen width is shorter than height or same, the Orientation Mode will have PORTRAIT.
 468    */
 469   enum class OrientationMode
 470   {
 471     PORTRAIT = 0,
 472     LANDSCAPE
 473   };
 474
 475   /**
 476    * Private constructor.
 477    * @sa Window::New()
 478    */
 479   Window();
 480
 481   /**
 482    * Destructor
 483    */
 484   ~Window() override;
 485
 486   /**
 487    * Second stage initialization
 488    */
 489   void Initialize(Any surface, const PositionSize& positionSize, const std::string& name, const std::string& className, WindowType type);
 490
 491   /**
 492    * Called when the window becomes iconified or deiconified.
 493    */
 494   void OnIconifyChanged(bool iconified);
 495
 496   /**
 497    * Called when the window focus is changed.
 498    */
 499   void OnFocusChanged(bool focusIn);
 500
 501   /**
 502    * Called when the output is transformed.
 503    */
 504   void OnOutputTransformed();
 505
 506   /**
 507    * Called when the window receives a delete request.
 508    */
 509   void OnDeleteRequest();
 510
 511   /**
 512    * Called when the window receives a Transition effect-start/end event.
 513    */
 514   void OnTransitionEffectEvent(WindowEffectState state, WindowEffectType type);
 515
 516   /**
 517    * @brief Called when window receives a keyboard repeat event.
 518    */
 519   void OnKeyboardRepeatSettingsChanged();
 520
 521   /**
 522    * @brief Called when the window redraw is requested.
 523    */
 524   void OnWindowRedrawRequest();
 525
 526   /**
 527    * @brief Called when the window is resized or moved by display server.
 528    *
 529    * @param[in] positionSize the updated window's position and size.
 530    */
 531   void OnUpdatePositionSize(Dali::PositionSize& positionSize);
 532
 533   /**
 534    * @brief Called when display server sent the auxiliary message.
 535    *
 536    * @param[in] key the auxiliary message's key.
 537    * @param[in] value the auxiliary message's value.
 538    * @param[in] options the auxiliary message's options. This is the list of string.
 539    */
 540   void OnAuxiliaryMessage(const std::string& key, const std::string& value, const Property::Array& options);
 541
 542   /**
 543    * @brief Called when Accessibility is enabled.
 544    *
 545    * This method is to register the window to accessibility bridge.
 546    */
 547   void OnAccessibilityEnabled();
 548
 549   /**
 550    * @brief Called when Accessibility is disabled.
 551    *
 552    * This method is to remove the window from accessibility bridge.
 553    */
 554   void OnAccessibilityDisabled();
 555
 556   /**
 557    * @brief Set available orientation to window base.
 558    */
 559   void SetAvailableAnlges(const std::vector<int>& angles);
 560
 561   /**
 562    * @brief Convert from window orientation to angle using OrientationMode.
 563    */
 564   int ConvertToAngle(WindowOrientation orientation);
 565
 566   /**
 567    * @brief Convert from angle to window orientation using OrientationMode.
 568    */
 569   WindowOrientation ConvertToOrientation(int angle) const;
 570
 571   /**
 572    * @brief Check available window orientation for Available orientation.
 573    */
 574   bool IsOrientationAvailable(WindowOrientation orientation) const;
 575
 576   /**
 577    * @brief Return the rect value to recalulate with the default system coordinates.
 578    *
 579    * Some native window APIs work the geometry value based on the default system coordinates.
 580    * IncludeInputRegion() and ExcludeInputRegion() are one of them.
 581    * When the window is rotated, current window's geometry already were set with the rotated angle.
 582    * If IncludeInputRegion() or ExcludeInputRegion() are called with rotated angle by application,
 583    * the rect's area should be re-calcuated on the default system coordinates.
 584    *
 585    * @param[in] rect the window's current position and size with current window rotation angle.
 586    * @return the re-calculated rect on the default system coordinates.
 587    */
 588   Rect<int> RecalculateRect(const Rect<int>& rect);
 589
 590 private: // Dali::Internal::Adaptor::SceneHolder
 591   /**
 592    * @copydoc Dali::Internal::Adaptor::SceneHolder::OnAdaptorSet
 593    */
 594   void OnAdaptorSet(Dali::Adaptor& adaptor) override;
 595
 596   /**
 597    * @copydoc Dali::Internal::Adaptor::SceneHolder::OnSurfaceSet
 598    */
 599   void OnSurfaceSet(Dali::RenderSurfaceInterface* surface) override;
 600
 601   /**
 602    * @copydoc Dali::Internal::Adaptor::SceneHolder::OnPause
 603    */
 604   void OnPause() override;
 605
 606   /**
 607    * @copydoc Dali::Internal::Adaptor::SceneHolder::OnResume
 608    */
 609   void OnResume() override;
 610
 611   /**
 612    * @copydoc Dali::Internal::Adaptor::SceneHolder::RecalculateTouchPosition
 613    */
 614   void RecalculateTouchPosition(Integration::Point& point) override;
 615
 616 private: // Dali::Internal::Adaptor::EventHandler::Observer
 617   /**
 618    * @copydoc Dali::Internal::Adaptor::EventHandler::Observer::OnTouchPoint
 619    */
 620   void OnTouchPoint(Dali::Integration::Point& point, int timeStamp) override;
 621
 622   /**
 623    * @copydoc Dali::Internal::Adaptor::EventHandler::Observer::OnWheelEvent
 624    */
 625   void OnWheelEvent(Dali::Integration::WheelEvent& wheelEvent) override;
 626
 627   /**
 628    * @copydoc Dali::Internal::Adaptor::EventHandler::Observer::OnKeyEvent
 629    */
 630   void OnKeyEvent(Dali::Integration::KeyEvent& keyEvent) override;
 631
 632   /**
 633    * @copydoc Dali::Internal::Adaptor::EventHandler::Observer::OnRotation
 634    */
 635   void OnRotation(const RotationEvent& rotation) override;
 636
 637 public: // Signals
 638   /**
 639    * @copydoc Dali::Window::FocusChangeSignal()
 640    */
 641   FocusChangeSignalType& FocusChangeSignal()
 642   {
 643     return mFocusChangeSignal;
 644   }
 645
 646   /**
 647    * @copydoc Dali::Window::ResizedSignal()
 648    */
 649   ResizeSignalType& ResizeSignal()
 650   {
 651     return mResizeSignal;
 652   }
 653
 654   /**
 655    * This signal is emitted when the window is requesting to be deleted
 656    */
 657   SignalType& DeleteRequestSignal()
 658   {
 659     return mDeleteRequestSignal;
 660   }
 661
 662   /**
 663    * @copydoc Dali::DevelWindow::VisibilityChangedSignal()
 664    */
 665   VisibilityChangedSignalType& VisibilityChangedSignal()
 666   {
 667     return mVisibilityChangedSignal;
 668   }
 669
 670   /**
 671    * @copydoc Dali::Window::SignalEventProcessingFinished()
 672    */
 673   Dali::DevelWindow::EventProcessingFinishedSignalType& EventProcessingFinishedSignal()
 674   {
 675     return mScene.EventProcessingFinishedSignal();
 676   }
 677
 678   /**
 679    * @copydoc Dali::DevelWindow::TransitionEffectEventSignal()
 680    */
 681   TransitionEffectEventSignalType& TransitionEffectEventSignal()
 682   {
 683     return mTransitionEffectEventSignal;
 684   }
 685
 686   /**
 687    * @copydoc Dali::DevelWindow::KeyboardRepeatSettingsChangedSignal()
 688    */
 689   KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal()
 690   {
 691     return mKeyboardRepeatSettingsChangedSignal;
 692   }
 693
 694   /**
 695    * @copydoc Dali::DevelWindow::AuxiliaryMessageSignal()
 696    */
 697   AuxiliaryMessageSignalType& AuxiliaryMessageSignal()
 698   {
 699     return mAuxiliaryMessageSignal;
 700   }
 701
 702   /**
 703    * @copydoc Dali::DevelWindow::AccessibilityHighlightSignal()
 704    */
 705   AccessibilityHighlightSignalType& AccessibilityHighlightSignal()
 706   {
 707     return mAccessibilityHighlightSignal;
 708   }
 709
 710 private:
 711   WindowRenderSurface* mWindowSurface; ///< The window rendering surface
 712   WindowBase*          mWindowBase;
 713   std::string          mName;
 714   std::string          mClassName;
 715   bool                 mIsTransparent : 1;
 716   bool                 mIsFocusAcceptable : 1;
 717   bool                 mIconified : 1;
 718   bool                 mOpaqueState : 1;
 719   bool                 mWindowRotationAcknowledgement : 1;
 720   bool                 mFocused : 1;
 721   Dali::Window         mParentWindow;
 722
 723   OrientationPtr   mOrientation;
 724   std::vector<int> mAvailableAngles;
 725   int              mPreferredAngle;
 726
 727   int mRotationAngle;                    ///< The angle of the rotation
 728   int mWindowWidth;                      ///< The width of the window
 729   int mWindowHeight;                     ///< The height of the window
 730
 731   EventHandlerPtr mEventHandler;         ///< The window events handler
 732
 733   OrientationMode mOrientationMode;      ///< The physical screen mode is portrait or landscape
 734
 735   int mNativeWindowId;                   ///< The Native Window Id
 736
 737   // Signals
 738   SignalType                              mDeleteRequestSignal;
 739   FocusChangeSignalType                   mFocusChangeSignal;
 740   ResizeSignalType                        mResizeSignal;
 741   VisibilityChangedSignalType             mVisibilityChangedSignal;
 742   TransitionEffectEventSignalType         mTransitionEffectEventSignal;
 743   KeyboardRepeatSettingsChangedSignalType mKeyboardRepeatSettingsChangedSignal;
 744   AuxiliaryMessageSignalType              mAuxiliaryMessageSignal;
 745   AccessibilityHighlightSignalType        mAccessibilityHighlightSignal;
 746 };
 747
 748 } // namespace Adaptor
 749 } // namespace Internal
 750
 751 // Helpers for public-api forwarding methods
 752
 753 inline Internal::Adaptor::Window& GetImplementation(Dali::Window& window)
 754 {
 755   DALI_ASSERT_ALWAYS(window && "Window handle is empty");
 756   BaseObject& object = window.GetBaseObject();
 757   return static_cast<Internal::Adaptor::Window&>(object);
 758 }
 759
 760 inline const Internal::Adaptor::Window& GetImplementation(const Dali::Window& window)
 761 {
 762   DALI_ASSERT_ALWAYS(window && "Window handle is empty");
 763   const BaseObject& object = window.GetBaseObject();
 764   return static_cast<const Internal::Adaptor::Window&>(object);
 765 }
 766
 767 } // namespace Dali
 768
 769 #endif // DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_IMPL_H