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

   1 #ifndef DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_BASE_H
   2 #define DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_BASE_H
   3
   4 /*
   5  * Copyright (c) 2023 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/integration-api/events/key-event-integ.h>
  23 #include <dali/integration-api/events/point.h>
  24 #include <dali/integration-api/events/wheel-event-integ.h>
  25 #include <cstdint>
  26 #include <string>
  27 #include <vector>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali/devel-api/adaptor-framework/mouse-in-out-event.h>
  31 #include <dali/devel-api/adaptor-framework/window-devel.h>
  32 #include <dali/internal/graphics/gles/egl-implementation.h>
  33 #include <dali/internal/window-system/common/damage-observer.h>
  34 #include <dali/internal/window-system/common/rotation-event.h>
  35 #include <dali/public-api/adaptor-framework/key-grab.h>
  36 #include <dali/public-api/adaptor-framework/style-change.h>
  37 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  38 #include <dali/public-api/adaptor-framework/window.h>
  39
  40 namespace Dali
  41 {
  42 namespace Internal
  43 {
  44 namespace Adaptor
  45 {
  46 /**
  47  * WindowBase interface
  48  */
  49 class WindowBase
  50 {
  51 public:
  52   /**
  53    * @brief Struct used to retrieve accessibility information
  54    */
  55   struct AccessibilityInfo
  56   {
  57     int gestureValue;
  58     int startX;
  59     int startY;
  60     int endX;
  61     int endY;
  62     int state;
  63     int eventTime;
  64   };
  65
  66   // Window
  67   typedef Signal<void(bool)>                                                           IconifySignalType;
  68   typedef Signal<void(bool)>                                                           MaximizeSignalType;
  69   typedef Signal<void(bool)>                                                           FocusSignalType;
  70   typedef Signal<void()>                                                               OutputSignalType;
  71   typedef Signal<void()>                                                               DeleteSignalType;
  72   typedef Signal<void(const DamageArea&)>                                              DamageSignalType;
  73   typedef Signal<void(const RotationEvent&)>                                           RotationSignalType;
  74   typedef Signal<void(WindowEffectState, WindowEffectType)>                            TransitionEffectEventSignalType;
  75   typedef Signal<void()>                                                               KeyboardRepeatSettingsChangedSignalType;
  76   typedef Signal<void()>                                                               WindowRedrawRequestSignalType;
  77   typedef Signal<void(Dali::PositionSize&)>                                            UpdatePositionSizeType;
  78   typedef Signal<void(const std::string&, const std::string&, const Property::Array&)> AuxiliaryMessageSignalType;
  79   typedef Signal<void(const Dali::DevelWindow::MouseInOutEvent&)>                      MouseInOutEventSignalType;
  80   typedef Signal<void(const Dali::DevelWindow::MouseRelativeEvent&)>                   MouseRelativeEventSignalType;
  81   typedef Signal<void(Dali::Int32Pair&)>                                               MoveCompletedSignalType;
  82   typedef Signal<void(Dali::Uint16Pair&)>                                              ResizeCompletedSignalType;
  83   typedef Signal<void(WindowInsetsPartType, WindowInsetsPartState, const Extents&)>    InsetsChangedSignalType;
  84   typedef Signal<void(const Dali::Int32Pair&, bool, bool)>                             PointerConstraintsSignalType;
  85
  86   // Input events
  87   typedef Signal<void(Integration::Point&, uint32_t)> TouchEventSignalType;
  88   typedef Signal<void(Integration::WheelEvent&)>      WheelEventSignalType;
  89   typedef Signal<void(Integration::KeyEvent&)>        KeyEventSignalType;
  90
  91   // Clipboard
  92   typedef Signal<void(void*)> SelectionSignalType;
  93
  94   // Accessibility
  95   typedef Signal<void(StyleChange::Type)> StyleSignalType;
  96
  97   /**
  98    * @brief Default constructor
  99    */
 100   WindowBase();
 101
 102   /**
 103    * @brief Destructor
 104    */
 105   virtual ~WindowBase();
 106
 107 public:
 108   /**
 109    * @brief Get the native window handle
 110    * @return The native window handle
 111    */
 112   virtual Any GetNativeWindow() = 0;
 113
 114   /**
 115    * @brief Get the native window id
 116    * @return The native window id
 117    */
 118   virtual int GetNativeWindowId() = 0;
 119
 120   /**
 121    * @brief Get the native window resource id assinged by window manager
 122    * @return The native window resource id
 123    */
 124   virtual std::string GetNativeWindowResourceId() = 0;
 125
 126   /**
 127    * @brief Create the egl window
 128    */
 129   virtual EGLNativeWindowType CreateEglWindow(int width, int height) = 0;
 130
 131   /**
 132    * @brief Destroy the egl window
 133    */
 134   virtual void DestroyEglWindow() = 0;
 135
 136   /**
 137    * @brief Set the egl window rotation
 138    */
 139   virtual void SetEglWindowRotation(int angle) = 0;
 140
 141   /**
 142    * @brief Set the egl window buffer transform
 143    */
 144   virtual void SetEglWindowBufferTransform(int angle) = 0;
 145
 146   /**
 147    * @brief Set the egl window transform
 148    */
 149   virtual void SetEglWindowTransform(int angle) = 0;
 150
 151   /**
 152    * @brief Resize the egl window
 153    */
 154   virtual void ResizeEglWindow(Dali::PositionSize positionSize) = 0;
 155
 156   /**
 157    * @brief Returns whether the egl window support rotation or not
 158    */
 159   virtual bool IsEglWindowRotationSupported() = 0;
 160
 161   /**
 162    * @brief Move the window
 163    */
 164   virtual void Move(Dali::PositionSize positionSize) = 0;
 165
 166   /**
 167    * @brief Resize the window
 168    */
 169   virtual void Resize(Dali::PositionSize positionSize) = 0;
 170
 171   /**
 172    * @brief Move and resize the window
 173    */
 174   virtual void MoveResize(Dali::PositionSize positionSize) = 0;
 175
 176   /**
 177    * @copydoc Dali::Window::SetLayout()
 178    */
 179   virtual void SetLayout(unsigned int numCols, unsigned int numRows, unsigned int column, unsigned int row, unsigned int colSpan, unsigned int rowSpan) = 0;
 180
 181   /**
 182    * @copydoc Dali::Window::SetClass()
 183    */
 184   virtual void SetClass(const std::string& name, const std::string& className) = 0;
 185
 186   /**
 187    * @copydoc Dali::Window::Raise()
 188    */
 189   virtual void Raise() = 0;
 190
 191   /**
 192    * @copydoc Dali::Window::Lower()
 193    */
 194   virtual void Lower() = 0;
 195
 196   /**
 197    * @copydoc Dali::Window::Activate()
 198    */
 199   virtual void Activate() = 0;
 200
 201   /**
 202    * @copydoc Dali::DevelWindow::Maximize()
 203    */
 204   virtual void Maximize(bool maximize) = 0;
 205
 206   /**
 207    * @copydoc Dali::DevelWindow::IsMaximized()
 208    */
 209   virtual bool IsMaximized() const = 0;
 210
 211   /**
 212    * @copydoc Dali::DevelWindow::SetMaximumSize()
 213    */
 214   virtual void SetMaximumSize(Dali::Window::WindowSize size) = 0;
 215
 216   /**
 217    * @copydoc Dali::DevelWindow::Minimize()
 218    */
 219   virtual void Minimize(bool minimize) = 0;
 220
 221   /**
 222    * @copydoc Dali::DevelWindow::IsMinimized()
 223    */
 224   virtual bool IsMinimized() const = 0;
 225
 226   /**
 227    * @copydoc Dali::DevelWindow::SetMimimumSize()
 228    */
 229   virtual void SetMimimumSize(Dali::Window::WindowSize size) = 0;
 230
 231   /**
 232    * @copydoc Dali::Window::SetAvailableOrientations()
 233    */
 234   virtual void SetAvailableAnlges(const std::vector<int>& angles) = 0;
 235
 236   /**
 237    * @copydoc Dali::Window::SetPreferredOrientation()
 238    */
 239   virtual void SetPreferredAngle(int angle) = 0;
 240
 241   /**
 242    * @copydoc Dali::Window::SetAcceptFocus()
 243    */
 244   virtual void SetAcceptFocus(bool accept) = 0;
 245
 246   /**
 247    * @copydoc Dali::Window::Show()
 248    */
 249   virtual void Show() = 0;
 250
 251   /**
 252    * @copydoc Dali::Window::Hide()
 253    */
 254   virtual void Hide() = 0;
 255
 256   /**
 257    * @copydoc Dali::Window::GetSupportedAuxiliaryHintCount()
 258    */
 259   virtual unsigned int GetSupportedAuxiliaryHintCount() const = 0;
 260
 261   /**
 262    * @copydoc Dali::Window::GetSupportedAuxiliaryHint()
 263    */
 264   virtual std::string GetSupportedAuxiliaryHint(unsigned int index) const = 0;
 265
 266   /**
 267    * @copydoc Dali::Window::AddAuxiliaryHint()
 268    */
 269   virtual unsigned int AddAuxiliaryHint(const std::string& hint, const std::string& value) = 0;
 270
 271   /**
 272    * @copydoc Dali::Window::RemoveAuxiliaryHint()
 273    */
 274   virtual bool RemoveAuxiliaryHint(unsigned int id) = 0;
 275
 276   /**
 277    * @copydoc Dali::Window::SetAuxiliaryHintValue()
 278    */
 279   virtual bool SetAuxiliaryHintValue(unsigned int id, const std::string& value) = 0;
 280
 281   /**
 282    * @copydoc Dali::Window::GetAuxiliaryHintValue()
 283    */
 284   virtual std::string GetAuxiliaryHintValue(unsigned int id) const = 0;
 285
 286   /**
 287    * @copydoc Dali::Window::GetAuxiliaryHintId()
 288    */
 289   virtual unsigned int GetAuxiliaryHintId(const std::string& hint) const = 0;
 290
 291   /**
 292    * @copydoc Dali::Window::SetInputRegion()
 293    */
 294   virtual void SetInputRegion(const Rect<int>& inputRegion) = 0;
 295
 296   /**
 297    * @copydoc Dali::Window::SetType()
 298    */
 299   virtual void SetType(Dali::WindowType type) = 0;
 300
 301   /**
 302    * @copydoc Dali::Window::GetType()
 303    */
 304   virtual Dali::WindowType GetType() const = 0;
 305
 306   /**
 307    * @copydoc Dali::Window::SetNotificationLevel()
 308    */
 309   virtual Dali::WindowOperationResult SetNotificationLevel(Dali::WindowNotificationLevel level) = 0;
 310
 311   /**
 312    * @copydoc Dali::Window::GetNotificationLevel()
 313    */
 314   virtual Dali::WindowNotificationLevel GetNotificationLevel() const = 0;
 315
 316   /**
 317    * @copydoc Dali::Window::SetOpaqueState()
 318    */
 319   virtual void SetOpaqueState(bool opaque) = 0;
 320
 321   /**
 322    * @copydoc Dali::Window::SetScreenOffMode()
 323    */
 324   virtual Dali::WindowOperationResult SetScreenOffMode(WindowScreenOffMode screenOffMode) = 0;
 325
 326   /**
 327    * @copydoc Dali::Window::GetScreenOffMode()
 328    */
 329   virtual WindowScreenOffMode GetScreenOffMode() const = 0;
 330
 331   /**
 332    * @copydoc Dali::Window::SetBrightness()
 333    */
 334   virtual Dali::WindowOperationResult SetBrightness(int brightness) = 0;
 335
 336   /**
 337    * @copydoc Dali::Window::GetBrightness()
 338    */
 339   virtual int GetBrightness() const = 0;
 340
 341   /**
 342    * @copydoc Dali::KeyGrab::GrabKey()
 343    */
 344   virtual bool GrabKey(Dali::KEY key, KeyGrab::KeyGrabMode grabMode) = 0;
 345
 346   /**
 347    * @copydoc Dali::KeyGrab::UngrabKey()
 348    */
 349   virtual bool UngrabKey(Dali::KEY key) = 0;
 350
 351   /**
 352    * @copydoc Dali::KeyGrab::GrabKeyList()
 353    */
 354   virtual bool GrabKeyList(const Dali::Vector<Dali::KEY>& key, const Dali::Vector<KeyGrab::KeyGrabMode>& grabMode, Dali::Vector<bool>& result) = 0;
 355
 356   /**
 357    * @copydoc Dali::KeyGrab::UngrabKeyList()
 358    */
 359   virtual bool UngrabKeyList(const Dali::Vector<Dali::KEY>& key, Dali::Vector<bool>& result) = 0;
 360
 361   /**
 362    * @brief Get DPI
 363    * @param[out] dpiHorizontal set to the horizontal dpi
 364    * @param[out] dpiVertical set to the vertical dpi
 365    */
 366   virtual void GetDpi(unsigned int& dpiHorizontal, unsigned int& dpiVertical) = 0;
 367
 368   /**
 369    * @brief Return the angle of the window's rotation.
 370    * @return The window orientation
 371    */
 372   virtual int GetWindowRotationAngle() const = 0;
 373
 374   /**
 375    * @brief Get the angle of screen rotation for the window
 376    * @return The screen orientation
 377    */
 378   virtual int GetScreenRotationAngle() = 0;
 379
 380   /**
 381    * @brief Set the screen rotation angle of the window
 382    */
 383   virtual void SetWindowRotationAngle(int degree) = 0;
 384
 385   /**
 386    * @brief Inform the window rotation is completed
 387    */
 388   virtual void WindowRotationCompleted(int degree, int width, int height) = 0;
 389
 390   /**
 391    * @brief starts the window is moved by display server
 392    */
 393   virtual void RequestMoveToServer() = 0;
 394
 395   /**
 396    * @brief starts the window is resized by display server
 397    *
 398    * @param[in] direction It is direction of the started edge/side.
 399    */
 400   virtual void RequestResizeToServer(WindowResizeDirection direction) = 0;
 401
 402   /**
 403    * @brief Enables the floating mode of window.
 404    *
 405    * The floating mode is to support making partial size window easliy.
 406    * It is useful to make popup style window
 407    * and this window is always upper than the other normal window.
 408    *
 409    * A special display server(as a Tizen display server) supports this mode.
 410    *
 411    * @param[in] enable Enable floating mode or not.
 412    */
 413   virtual void EnableFloatingMode(bool enable) = 0;
 414
 415   /**
 416    * @brief Gets whether floating mode is enabled or not.
 417    */
 418   virtual bool IsFloatingModeEnabled() const = 0;
 419
 420   /**
 421    * @copydoc Dali::Window::SetTransparency()
 422    */
 423   virtual void SetTransparency(bool transparent) = 0;
 424
 425   /**
 426    * @copydoc Dali::Window::SetParent()
 427    */
 428   virtual void SetParent(WindowBase* parentWinBase, bool belowParent) = 0;
 429
 430   /**
 431    * @brief Create a sync fence that can tell the frame is rendered by the graphics driver.
 432    * @return The file descriptor that tells when it is rendered.
 433    */
 434   virtual int CreateFrameRenderedSyncFence() = 0;
 435
 436   /**
 437    * @brief Create a sync fence that can tell the frame is presented by the display server.
 438    * @return The file descriptor that tells when it is presented.
 439    */
 440   virtual int CreateFramePresentedSyncFence() = 0;
 441
 442   /**
 443    * @copydoc Dali::Window::SetPositionSizeWithAngle()
 444    */
 445   virtual void SetPositionSizeWithAngle(PositionSize positionSize, int angle) = 0;
 446
 447   /**
 448    * @brief Initialize for Ime window.
 449    * It should be called when the window is only used for Ime keyboard window.
 450    */
 451   virtual void InitializeIme() = 0;
 452
 453   /**
 454    * @brief Send the signal to display server for Ime Window is ready to render.
 455    * It is used for compositing by display server.
 456    */
 457   virtual void ImeWindowReadyToRender() = 0;
 458
 459   /**
 460    * @brief Includes input region.
 461    * @param[in] inputRegion The added region to accept input events.
 462    */
 463   virtual void IncludeInputRegion(const Rect<int>& inputRegion) = 0;
 464
 465   /**
 466    * @brief Excludes input region.
 467    * @param[in] inputRegion The subtracted region to except input events.
 468    */
 469   virtual void ExcludeInputRegion(const Rect<int>& inputRegion) = 0;
 470
 471   /**
 472    * @brief Sets the pointer constraints lock.
 473    * @return Returns true if PointerConstraintsLock succeeds.
 474    */
 475   virtual bool PointerConstraintsLock() = 0;
 476
 477   /**
 478    * @brief Sets the pointer constraints unlock.
 479    * @return Returns true if PointerConstraintsUnlock succeeds.
 480    */
 481   virtual bool PointerConstraintsUnlock() = 0;
 482
 483   /**
 484    * @brief Sets the locked pointer region
 485    *
 486    * @param[in] x The x position.
 487    * @param[in] y The y position.
 488    * @param[in] width The width.
 489    * @param[in] height The height
 490    */
 491   virtual void LockedPointerRegionSet(int32_t x, int32_t y, int32_t width, int32_t height) = 0;
 492
 493   /**
 494    * @brief Sets the locked pointer cursor position hintset
 495    *
 496    * @param[in] x The x position.
 497    * @param[in] y The y position.
 498    */
 499   virtual void LockedPointerCursorPositionHintSet(int32_t x, int32_t y) = 0;
 500
 501   /**
 502    * @brief Sets the pointer warp. The pointer moves to the set coordinates.
 503    *
 504    * @param[in] x The x position.
 505    * @param[in] y The y position.
 506    * @return Returns true if PointerWarp succeeds.
 507    */
 508   virtual bool PointerWarp(int32_t x, int32_t y) = 0;
 509
 510   /**
 511    * @brief Sets visibility on/off of cursor
 512    *
 513    * @param[in] visible The visibility of cursor
 514    */
 515   virtual void CursorVisibleSet(bool visible) = 0;
 516
 517   /**
 518    * @brief Requests grab key events according to the requested device subtype
 519    *
 520    * @param[in] deviceSubclass The deviceSubclass type.
 521    * @return Returns true if KeyboardGrab succeeds.
 522    */
 523   virtual bool KeyboardGrab(Device::Subclass::Type deviceSubclass) = 0;
 524
 525   /**
 526    * @brief Requests ungrab key events
 527    *
 528    * @param[in] window The window instance.
 529    * @return Returns true if KeyboardUnGrab succeeds.
 530    */
 531   virtual bool KeyboardUnGrab() = 0;
 532
 533   /**
 534    * @brief Sets full screen sized window.
 535    * If full screen size is set for the window,
 536    * window will be resized with full screen size.
 537    * In addition, the full screen sized window's z-order is the highest.
 538    *
 539    * @param[in] fullscreen true to set fullscreen, false to unset.
 540    */
 541   virtual void SetFullScreen(bool fullscreen) = 0;
 542
 543   /**
 544    * @brief Gets whether the full screen sized window or not
 545    *
 546    * @return Returns true if the full screen sized window is.
 547    */
 548   virtual bool GetFullScreen() = 0;
 549
 550   /**
 551    * @brief Enables or disables front buffer rendering.
 552    * @param[in] enable true to enable front buffer rendering, false to disable.
 553    */
 554   virtual void SetFrontBufferRendering(bool enable) = 0;
 555
 556     /**
 557    * @brief Enables or disables front buffer rendering.
 558    * @return Returns whether front buffer rendering has been enabled or not.
 559    */
 560   virtual bool GetFrontBufferRendering() = 0;
 561
 562   /**
 563    * @brief Sets front buffer rendering to the egl window.
 564    * @param[in] enable True to enable front buffer rendering mode, False to otherwise.
 565    */
 566   virtual void SetEglWindowFrontBufferMode(bool enable) = 0;
 567
 568   // Signals
 569
 570   /**
 571    * @brief This signal is emitted when the window becomes iconified or deiconified.
 572    */
 573   IconifySignalType& IconifyChangedSignal();
 574
 575   /**
 576    * @brief This signal is emitted when the window becomes maximized or unmaximized.
 577    */
 578   MaximizeSignalType& MaximizeChangedSignal();
 579
 580   /**
 581    * @brief This signal is emitted when the window focus is changed.
 582    */
 583   FocusSignalType& FocusChangedSignal();
 584
 585   /**
 586    * @brief This signal is emitted when the output is transformed.
 587    */
 588   OutputSignalType& OutputTransformedSignal();
 589
 590   /**
 591    * @brief This signal is emitted when the window receives a delete request.
 592    */
 593   DeleteSignalType& DeleteRequestSignal();
 594
 595   /**
 596    * @brief This signal is emitted when the window is damaged.
 597    */
 598   DamageSignalType& WindowDamagedSignal();
 599
 600   /**
 601    * @brief This signal is emitted when a rotation event is recevied.
 602    */
 603   RotationSignalType& RotationSignal();
 604
 605   /**
 606    * @brief This signal is emitted when a touch event is received.
 607    */
 608   TouchEventSignalType& TouchEventSignal();
 609
 610   /**
 611    * @brief This signal is emitted when a mouse wheel is received.
 612    */
 613   WheelEventSignalType& WheelEventSignal();
 614
 615   /**
 616    * @brief This signal is emitted when a key event is received.
 617    */
 618   KeyEventSignalType& KeyEventSignal();
 619
 620   /**
 621    * @brief This signal is emitted when the source window notifies us the content in clipboard is selected.
 622    */
 623   SelectionSignalType& SelectionDataSendSignal();
 624
 625   /**
 626    * @brief This signal is emitted when the source window sends us about the selected content.
 627    */
 628   SelectionSignalType& SelectionDataReceivedSignal();
 629
 630   /**
 631    * @brief This signal is emitted when the style is changed.
 632    */
 633   StyleSignalType& StyleChangedSignal();
 634
 635   /**
 636    * @brief This signal is emitted when window's transition animation is started or ended.
 637    */
 638   TransitionEffectEventSignalType& TransitionEffectEventSignal();
 639
 640   /**
 641    * @brief This signal is emitted when the keyboard repeat is changed.
 642    */
 643   KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal();
 644
 645   /**
 646    * @brief This signal is emitted when the window redraw is requested.
 647    */
 648   WindowRedrawRequestSignalType& WindowRedrawRequestSignal();
 649
 650   /**
 651    * @brief This signal is emitted when the window's geometry data is changed by display server or client.
 652    * It is based on configure noification event.
 653    */
 654   UpdatePositionSizeType& UpdatePositionSizeSignal();
 655
 656   /**
 657    * @brief This signal is emitted when the window is received the auxiliary message from display server.
 658    */
 659   AuxiliaryMessageSignalType& AuxiliaryMessageSignal();
 660
 661   /**
 662    * @brief This signal is emitted when a mouse in or out event is recevied.
 663    */
 664   MouseInOutEventSignalType& MouseInOutEventSignal();
 665
 666   /**
 667    * @brief This signal is emitted when a mouse relative event is recevied.
 668    */
 669   MouseRelativeEventSignalType& MouseRelativeEventSignal();
 670
 671   /**
 672    * @brief This signal is emitted when window has been moved by then display server.
 673    * To be moved the window by display server, RequestMoveToServer() should be called.
 674    * After the moving job is finished, this function will be called.
 675    */
 676   MoveCompletedSignalType& MoveCompletedSignal();
 677
 678   /**
 679    * @brief This signal is emitted when window has been resized by then display server.
 680    * To be resized the window by display server, RequestResizeToServer() should be called.
 681    * After the resizing job is finished, this function will be called.
 682    */
 683   ResizeCompletedSignalType& ResizeCompletedSignal();
 684
 685   /**
 686    * @brief This signal is emitted when window insets are changed by appearing or disappearing indicator, virtual keyboard, or clipboard.
 687    */
 688   InsetsChangedSignalType& InsetsChangedSignal();
 689
 690   /**
 691    * @brief This signal is emitted when window pointer is locked/unlocked
 692    */
 693   PointerConstraintsSignalType& PointerConstraintsSignal();
 694
 695 protected:
 696   // Undefined
 697   WindowBase(const WindowBase&) = delete;
 698
 699   // Undefined
 700   WindowBase& operator=(const WindowBase& rhs) = delete;
 701
 702 protected:
 703   IconifySignalType                       mIconifyChangedSignal;
 704   MaximizeSignalType                      mMaximizeChangedSignal;
 705   FocusSignalType                         mFocusChangedSignal;
 706   OutputSignalType                        mOutputTransformedSignal;
 707   DeleteSignalType                        mDeleteRequestSignal;
 708   DamageSignalType                        mWindowDamagedSignal;
 709   RotationSignalType                      mRotationSignal;
 710   TouchEventSignalType                    mTouchEventSignal;
 711   WheelEventSignalType                    mWheelEventSignal;
 712   KeyEventSignalType                      mKeyEventSignal;
 713   SelectionSignalType                     mSelectionDataSendSignal;
 714   SelectionSignalType                     mSelectionDataReceivedSignal;
 715   StyleSignalType                         mStyleChangedSignal;
 716   TransitionEffectEventSignalType         mTransitionEffectEventSignal;
 717   KeyboardRepeatSettingsChangedSignalType mKeyboardRepeatSettingsChangedSignal;
 718   WindowRedrawRequestSignalType           mWindowRedrawRequestSignal;
 719   UpdatePositionSizeType                  mUpdatePositionSizeSignal;
 720   AuxiliaryMessageSignalType              mAuxiliaryMessageSignal;
 721   MouseInOutEventSignalType               mMouseInOutEventSignal;
 722   MouseRelativeEventSignalType            mMouseRelativeEventSignal;
 723   MoveCompletedSignalType                 mMoveCompletedSignal;
 724   ResizeCompletedSignalType               mResizeCompletedSignal;
 725   InsetsChangedSignalType                 mInsetsChangedSignal;
 726   PointerConstraintsSignalType            mPointerConstraintsSignal;
 727 };
 728
 729 } // namespace Adaptor
 730
 731 } // namespace Internal
 732
 733 } // namespace Dali
 734
 735 #endif // DALI_INTERNAL_WINDOWSYSTEM_COMMON_WINDOW_BASE_H