dali/devel-api/adaptor-framework/window-devel.h

   1 #ifndef DALI_WINDOW_DEVEL_H
   2 #define DALI_WINDOW_DEVEL_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 <memory>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/devel-api/adaptor-framework/mouse-in-out-event.h>
  26 #include <dali/devel-api/adaptor-framework/mouse-relative-event.h>
  27 #include <dali/devel-api/adaptor-framework/pointer-constraints-event.h>
  28 #include <dali/public-api/adaptor-framework/window-enumerations.h>
  29 #include <dali/public-api/adaptor-framework/window.h>
  30 #include <dali/public-api/common/vector-wrapper.h>
  31
  32 namespace Dali
  33 {
  34 class KeyEvent;
  35 class TouchEvent;
  36 class HoverEvent;
  37 class WheelEvent;
  38 class RenderTaskList;
  39 struct TouchPoint;
  40
  41 namespace DevelWindow
  42 {
  43 typedef Signal<void()>                                                               EventProcessingFinishedSignalType;       ///< Event Processing finished signal type
  44 typedef Signal<void(const KeyEvent&)>                                                KeyEventSignalType;                      ///< Key event signal type
  45 typedef Signal<void(const TouchEvent&)>                                              TouchEventSignalType;                    ///< Touch signal type
  46 typedef Signal<void(const WheelEvent&)>                                              WheelEventSignalType;                    ///< Wheel signal type
  47 typedef Signal<void(Window, bool)>                                                   VisibilityChangedSignalType;             ///< Visibility changed signal type
  48 typedef Signal<void(Window, WindowEffectState, WindowEffectType)>                    TransitionEffectEventSignalType;         ///< Effect signal type and state
  49 typedef Signal<void()>                                                               KeyboardRepeatSettingsChangedSignalType; ///< Keyboard repeat settings changed signal type
  50 typedef Signal<void(const std::string&, const std::string&, const Property::Array&)> AuxiliaryMessageSignalType;              ///< Auxiliary message signal type
  51 typedef Signal<void(Window, bool)>                                                   AccessibilityHighlightSignalType;        ///< Accessibility Highlight signal type
  52 typedef Signal<bool(const KeyEvent&)>                                                InterceptKeyEventSignalType;             ///< Intercept Key event signal type
  53 typedef Signal<void(Window, Dali::Window::WindowPosition)>                           MovedSignalType;                         ///< Window Moved signal type
  54 typedef Signal<void(Window, Dali::WindowOrientation)>                                OrientationChangedSignalType;            ///< Window orientation changed signal type
  55 typedef Signal<void(Window, const Dali::DevelWindow::MouseInOutEvent&)>              MouseInOutEventSignalType;               ///< MouseInOutEvent signal type
  56 typedef Signal<void(Window, const Dali::DevelWindow::MouseRelativeEvent&)>           MouseRelativeEventSignalType;            ///< MouseRelativeEvent signal type
  57 typedef Signal<void(Window, Dali::Window::WindowPosition)>                           MoveCompletedSignalType;                 ///< Window Moved by Server signal type
  58 typedef Signal<void(Window, Dali::Window::WindowSize)>                               ResizeCompletedSignalType;               ///< Window Resized by Server signal type
  59 typedef Signal<void(WindowInsetsPartType, WindowInsetsPartState, const Extents&)>    InsetsChangedSignalType;                 ///< InsetsChanged signal type
  60 typedef Signal<void(Window, const Dali::DevelWindow::PointerConstraintsEvent&)>      PointerConstraintsSignalType;            ///< PointerConstraintsEvent signal type
  61
  62 /**
  63  * @brief Creates an initialized handle to a new Window.
  64  *
  65  * @param[in] surface Can be a window or pixmap.
  66  * @param[in] windowPosition The position and size of the Window
  67  * @param[in] name The Window title
  68  * @param[in] isTransparent Whether Window is transparent
  69  * @return A new window
  70  * @note This creates an extra window in addition to the default main window
  71  */
  72 DALI_ADAPTOR_API Window New(Any surface, PositionSize windowPosition, const std::string& name, bool isTransparent = false);
  73
  74 /**
  75  * @brief Creates an initialized handle to a new Window.
  76  *
  77  * @param[in] surface Can be a window or pixmap.
  78  * @param[in] windowPosition The position and size of the Window
  79  * @param[in] name The Window title
  80  * @param[in] className The Window class name
  81  * @param[in] isTransparent Whether Window is transparent
  82  * @note This creates an extra window in addition to the default main window
  83  * @return A new Window
  84  */
  85 DALI_ADAPTOR_API Window New(Any surface, PositionSize windowPosition, const std::string& name, const std::string& className, bool isTransparent = false);
  86
  87 /**
  88  * @brief Sets position and size of the window. This API guarantees that both moving and resizing of window will appear on the screen at once.
  89  *
  90  * @param[in] window The window instance
  91  * @param[in] positionSize The new window position and size
  92  */
  93 DALI_ADAPTOR_API void SetPositionSize(Window window, PositionSize positionSize);
  94
  95 /**
  96  * @brief Retrieve the window that the given actor is added to.
  97  *
  98  * @param[in] actor The actor
  99  * @return The window the actor is added to or an empty handle if the actor is not added to any window.
 100  */
 101 DALI_ADAPTOR_API Window Get(Actor actor);
 102
 103 /**
 104  * @brief This signal is emitted just after the event processing is finished.
 105  *
 106  * @param[in] window The window instance
 107  * @return The signal to connect to
 108  */
 109 DALI_ADAPTOR_API EventProcessingFinishedSignalType& EventProcessingFinishedSignal(Window window);
 110
 111 /**
 112  * @brief This signal is emitted when wheel event is received.
 113  *
 114  * A callback of the following type may be connected:
 115  * @code
 116  *   void YourCallbackName(const WheelEvent& event);
 117  * @endcode
 118  * @param[in] window The window instance
 119  * @return The signal to connect to
 120  */
 121 DALI_ADAPTOR_API WheelEventSignalType& WheelEventSignal(Window window);
 122
 123 /**
 124  * @brief This signal is emitted when the window is shown or hidden.
 125  *
 126  * A callback of the following type may be connected:
 127  * @code
 128  *   void YourCallbackName( Window window, bool visible );
 129  * @endcode
 130  * @param[in] window The window instance
 131  * @return The signal to connect to
 132  */
 133 DALI_ADAPTOR_API VisibilityChangedSignalType& VisibilityChangedSignal(Window window);
 134
 135 /**
 136  * @brief This signal is emitted for transition effect.
 137  *
 138  * The transition animation is appeared when the window is shown/hidden.
 139  * When the animation is started, START signal is emitted.
 140  * Then the animation is ended, END signal is emitted, too.
 141  * A callback of the following type may be connected:
 142  * @code
 143  *   void YourCallbackName( Window window, EffectState state, EffectType type );
 144  * @endcode
 145  * @param[in] window The window instance
 146  * @return The signal to connect to
 147  */
 148 DALI_ADAPTOR_API TransitionEffectEventSignalType& TransitionEffectEventSignal(Window window);
 149
 150 /**
 151  * @brief This signal is emitted just after the keyboard repeat setting is changed globally.
 152  *
 153  * @param[in] window The window instance
 154  * @return The signal to connect to
 155  */
 156 DALI_ADAPTOR_API KeyboardRepeatSettingsChangedSignalType& KeyboardRepeatSettingsChangedSignal(Window window);
 157
 158 /**
 159  * @brief This signal is emitted when window's auxiliary was changed then display server sent the message.
 160  *
 161  * Auxiliary message is sent by display server.
 162  * When client application added the window's auxiliary hint and if the auxiliary is changed,
 163  * display server send the auxiliary message.
 164  * Auxiliary message has the key, value and options.
 165  *
 166  * @param[in] window The window instance
 167  * @return The signal to connect to
 168  */
 169 DALI_ADAPTOR_API AuxiliaryMessageSignalType& AuxiliaryMessageSignal(Window window);
 170
 171 /**
 172  * @brief This signal is emitted when the window needs to grab or clear accessibility highlight.
 173  * The highlight indicates that it is an object to interact with the user regardless of focus.
 174  * After setting the highlight on the object, you can do things that the object can do, such as
 175  * giving or losing focus.
 176  *
 177  * This signal is emitted by Dali::Accessibility::Component::GrabHighlight
 178  * and Dali::Accessibility::Component::ClearHighlight
 179  *
 180  * A callback of the following type may be connected:
 181  * @code
 182  *   void YourCallbackName( Window window, bool highlight );
 183  * @endcode
 184  *
 185  * @param[in] window The window instance
 186  * @return The signal to connect to
 187  */
 188 DALI_ADAPTOR_API AccessibilityHighlightSignalType& AccessibilityHighlightSignal(Window window);
 189
 190 /**
 191  * @brief Sets parent window of the window.
 192  *
 193  * After setting that, these windows do together when raise-up, lower and iconified/deiconified.
 194  * Initially, the window is located on top of the parent. The window can go below parent by calling Lower().
 195  * If parent's window stack is changed by calling Raise() or Lower(), child windows are located on top of the parent again.
 196  *
 197  * @param[in] window The window instance
 198  * @param[in] parent The parent window instance
 199  */
 200 DALI_ADAPTOR_API void SetParent(Window window, Window parent);
 201
 202 /**
 203  * @brief Sets parent window of the window.
 204  *
 205  * After setting that, these windows do together when raise-up, lower and iconified/deiconified.
 206  * This function has the additional flag whether the child is located above or below of the parent.
 207  *
 208  * @param[in] window The window instance
 209  * @param[in] parent The parent window instance
 210  * @param[in] belowParent The flag is whether the child is located above or below of the parent.
 211  */
 212 DALI_ADAPTOR_API void SetParent(Window window, Window parent, bool belowParent);
 213
 214 /**
 215  * @brief Unsets parent window of the window.
 216  *
 217  * After unsetting, the window is disconnected his parent window.
 218  *
 219  * @param[in] window The window instance
 220  */
 221 DALI_ADAPTOR_API void Unparent(Window window);
 222
 223 /**
 224  * @brief Gets parent window of the window.
 225  *
 226  * @param[in] window The window instance
 227  * @return The parent window of the window
 228  */
 229 DALI_ADAPTOR_API Window GetParent(Window window);
 230
 231 /**
 232  * @brief Gets current orientation of the window.
 233  *
 234  * @param[in] window The window instance
 235  * @return The current window orientation if previously set, or none
 236  */
 237 DALI_ADAPTOR_API WindowOrientation GetCurrentOrientation(Window window);
 238
 239 /**
 240  * @brief Gets current physical orientation of the window.
 241  *
 242  * It means current physical rotation angle of the window.
 243  * If the height of the display device's area is greater than the width,
 244  * default current orientation is PORTRAIT and current physical orientation angle is 0.
 245  * If the width of the display device's area is greater than the height,
 246  * default current orientation is LANDSCAPE and current physical orientation angle is 0.
 247  *
 248  * @param[in] window The window instance
 249  * @return The current physical orientation degree of the window. It is one of them as 0, 90, 180 and 270.
 250  */
 251 DALI_ADAPTOR_API int GetPhysicalOrientation(Window window);
 252
 253 /**
 254  * @brief Sets available orientations of the window.
 255  *
 256  * This API is for setting several orientations one time.
 257  *
 258  * @param[in] window The window instance
 259  * @param[in] orientations The available orientation list to add
 260  */
 261 DALI_ADAPTOR_API void SetAvailableOrientations(Window window, const Dali::Vector<WindowOrientation>& orientations);
 262
 263 /**
 264  * @brief Gets current window ID.
 265  *
 266  * @param[in] window The window instance
 267  */
 268 DALI_ADAPTOR_API int32_t GetNativeId(Window window);
 269
 270 /**
 271  * @brief Adds a callback that is called when the frame rendering is done by the graphics driver.
 272  *
 273  * @param[in] window The window instance
 274  * @param[in] callback The function to call
 275  * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
 276  *
 277  * @note A callback of the following type may be used:
 278  * @code
 279  *   void MyFunction( int frameId );
 280  * @endcode
 281  * This callback will be deleted once it is called.
 282  *
 283  * @note Ownership of the callback is passed onto this class.
 284  */
 285 DALI_ADAPTOR_API void AddFrameRenderedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId);
 286
 287 /**
 288  * @brief Adds a callback that is called when the frame is displayed on the display.
 289  *
 290  * @param[in] window The window instance
 291  * @param[in] callback The function to call
 292  * @param[in] frameId The Id to specify the frame. It will be passed when the callback is called.
 293  *
 294  * @note A callback of the following type may be used:
 295  * @code
 296  *   void MyFunction( int frameId );
 297  * @endcode
 298  * This callback will be deleted once it is called.
 299  *
 300  * @note Ownership of the callback is passed onto this class.
 301  */
 302 DALI_ADAPTOR_API void AddFramePresentedCallback(Window window, std::unique_ptr<CallbackBase> callback, int32_t frameId);
 303
 304 /**
 305  * @brief Sets window position and size for specific orientation.
 306  * This api reserves the position and size per orientation to display server.
 307  * When the device is rotated, the window is moved/resized with the reserved position/size by display server.
 308  *
 309  * @param[in] window The window instance
 310  * @param[in] positionSize The reserved position and size for the orientation
 311  * @param[in] orientation The orientation
 312  *
 313  * @note Currently, it only works when the window's type is WindowType::IME.
 314  * @note To set WindowType::IME, use Application New(... WindowType type), not Window::SetType().
 315  * @note This function is only useful in Tizen world.
 316  */
 317 DALI_ADAPTOR_API void SetPositionSizeWithOrientation(Window window, PositionSize positionSize, WindowOrientation orientation);
 318
 319 /**
 320  * @brief Requests to display server for the window is moved by display server.
 321  *
 322  * This function should be called in mouse down event callback function.
 323  * After this function is called in mouse down event callback function, the window is moved with mouse move event.
 324  * When mouse up event happens, the window moved work is finished.
 325  *
 326  * @param[in] window The window instance
 327  */
 328 DALI_ADAPTOR_API void RequestMoveToServer(Window window);
 329
 330 /**
 331  * @brief Requests to display server for the window is resized by display server.
 332  *
 333  * This function should be called in mouse down event callback function.
 334  * After this function is called in mouse down event callback function, the window is resized with mouse move event.
 335  * The direction is selected one of eight ways.
 336  * When mouse up event happens, the window resized work is finished.
 337  *
 338  * @param[in] window The window instance
 339  * @param[in] direction it is indicated the window's side or edge for starting point.
 340  */
 341 DALI_ADAPTOR_API void RequestResizeToServer(Window window, WindowResizeDirection direction);
 342
 343 /**
 344  * @brief Enables the floating mode of window.
 345  *
 346  * The floating mode is to support making partial size window easliy.
 347  * It is useful to make popup style window and this window is always upper than the other normal window.
 348  * In addition, it is easy to change between popup style and normal style window.
 349  *
 350  * A special display server(as a Tizen display server) supports this mode.
 351  *
 352  * @param[in] window The window instance.
 353  * @param[in] enable Enable floating mode or not.
 354  */
 355 DALI_ADAPTOR_API void EnableFloatingMode(Window window, bool enable);
 356
 357 /**
 358  * @brief Returns whether the window is floating mode or not.
 359  *
 360  * @param[in] window The window instance.
 361  * @return True if the window is enabled floating mode, false otherwise.
 362  */
 363 DALI_ADAPTOR_API bool IsFloatingModeEnabled(Window window);
 364
 365 /**
 366  * @brief Includes input region.
 367  *
 368  * This function inlcudes input regions.
 369  * It can be used multiple times and supports multiple regions.
 370  * It means input region will be extended.
 371  *
 372  * This input is related to mouse and touch event.
 373  * If device has touch screen, this function is useful.
 374  * Otherwise device does not have that, we can use it after connecting mouse to the device.
 375  *
 376  * @param[in] window The window instance.
 377  * @param[in] inputRegion The added region to accept input events.
 378  */
 379 DALI_ADAPTOR_API void IncludeInputRegion(Window window, const Rect<int>& inputRegion);
 380
 381 /**
 382  * @brief Excludes input region.
 383  *
 384  * This function excludes input regions.
 385  * It can be used multiple times and supports multiple regions.
 386  * It means input region will be reduced.
 387  * Nofice, should be set input area by IncludeInputRegion() before this function is used.
 388  *
 389  * This input is related to mouse and touch event.
 390  * If device has touch screen, this function is useful.
 391  * Otherwise device does not have that, we can use it after connecting mouse to the device.
 392  *
 393  * @param[in] window The window instance.
 394  * @param[in] inputRegion The subtracted region to except input events.
 395  */
 396 DALI_ADAPTOR_API void ExcludeInputRegion(Window window, const Rect<int>& inputRegion);
 397
 398 /**
 399  * @brief Sets the necessary for window rotation Acknowledgement.
 400  * After this function called, SendRotationCompletedAcknowledgement() should be called to complete window rotation.
 401  *
 402  * This function is supprot that application has the window rotation acknowledgement's control.
 403  * It means display server waits when application's rotation work is finished.
 404  * It is useful application has the other rendering engine which works asynchronous.
 405  * For instance, GlView.
 406  * It only works on Tizen device.
 407  *
 408  * @param[in] window The window instance.
 409  * @param[in] needAcknowledgement the flag is true if window rotation acknowledge is sent.
 410  */
 411 DALI_ADAPTOR_API void SetNeedsRotationCompletedAcknowledgement(Window window, bool needAcknowledgement);
 412
 413 /**
 414  * @brief send the Acknowledgement to complete window rotation.
 415  * For this function, SetNeedsRotationCompletedAcknowledgement should be already called with true.
 416  *
 417  * @param[in] window The window instance.
 418  */
 419 DALI_ADAPTOR_API void SendRotationCompletedAcknowledgement(Window window);
 420
 421 /**
 422  * @brief Feed (Send) touch event to window
 423  * @param[in] window The window instance
 424  * @param[in] point The touch point
 425  * @param[in] timeStamp The time stamp
 426  */
 427 DALI_ADAPTOR_API void FeedTouchPoint(Window window, const Dali::TouchPoint& point, int32_t timeStamp);
 428
 429 /**
 430  * @brief Feed (Send) wheel event to window
 431  * @param[in] window The window instance
 432  * @param[in] wheelEvent The wheel event
 433  */
 434 DALI_ADAPTOR_API void FeedWheelEvent(Window window, const Dali::WheelEvent& wheelEvent);
 435
 436 /**
 437  * @brief Feed (Send) key event to window
 438  * @param[in] window The window instance
 439  * @param[in] keyEvent The key event holding the key information.
 440  */
 441 DALI_ADAPTOR_API void FeedKeyEvent(Window window, const Dali::KeyEvent& keyEvent);
 442
 443 /**
 444  * @brief Feed (Send) hover event to window
 445  * @param[in] window The window instance
 446  * @param[in] point The touch point that create a hover event
 447  */
 448 DALI_ADAPTOR_API void FeedHoverEvent(Window window, const Dali::TouchPoint& point);
 449
 450 /**
 451  * @brief Maximizes window's size.
 452  * If this function is called with true, window will be resized with screen size.
 453  * Otherwise window will be resized with previous size.
 454  * It is for the window's MAX button in window's border.
 455  *
 456  * It is for client application.
 457  * If window border is supported by display server, it is not necessary.
 458  *
 459  * @param[in] window The window instance.
 460  * @param[in] maximize If window is maximized or unmaximized.
 461  */
 462 DALI_ADAPTOR_API void Maximize(Window window, bool maximize);
 463
 464 /**
 465  * @brief Returns whether the window is maximized or not.
 466  *
 467  * @param[in] window The window instance.
 468  * @return True if the window is maximized, false otherwise.
 469  */
 470 DALI_ADAPTOR_API bool IsMaximized(Window window);
 471
 472 /**
 473  * @brief Sets window's maximum size.
 474  *
 475  * It is to set the maximized size when window is maximized or the window's size is increased by RequestResizeToServer().
 476  * Although the size is set by this function, window's size can be increased over the limitation by SetPositionSize() or SetSize().
 477  *
 478  * After setting, if Maximize() is called, window is resized with the setting size and move the center.
 479  *
 480  * @param[in] window The window instance.
 481  * @param[in] size the maximum size
 482  */
 483 DALI_ADAPTOR_API void SetMaximumSize(Window window, Dali::Window::WindowSize size);
 484
 485 /**
 486  * @brief Minimizes window's size.
 487  * If this function is called with true, window will be iconified.
 488  * Otherwise window will be activated.
 489  * It is for the window's MIN button in window border.
 490  *
 491  * It is for client application.
 492  * If window border is supported by display server, it is not necessary.
 493  *
 494  * @param[in] window The window instance.
 495  * @param[in] minimize If window is minimized or unminimized(activated).
 496  */
 497 DALI_ADAPTOR_API void Minimize(Window window, bool minimize);
 498
 499 /**
 500  * @brief Returns whether the window is minimized or not.
 501  *
 502  * @param[in] window The window instance.
 503  * @return True if the window is minimized, false otherwise.
 504  */
 505 DALI_ADAPTOR_API bool IsMinimized(Window window);
 506
 507 /**
 508  * @brief Sets window's minimum size.
 509  *
 510  * It is to set the minimum size when window's size is decreased by RequestResizeToServer().
 511  * Although the size is set by this function, window's size can be decreased over the limitation by SetPositionSize() or SetSize().
 512  *
 513  * @param[in] window The window instance.
 514  * @param[in] size the minimum size
 515  */
 516 DALI_ADAPTOR_API void SetMimimumSize(Window window, Dali::Window::WindowSize size);
 517
 518 /**
 519  * @brief Query whether window is rotating or not.
 520  *
 521  * @param[in] window The window instance.
 522  * @return true if window is rotating, false otherwise.
 523  */
 524 DALI_ADAPTOR_API bool IsWindowRotating(Window window);
 525
 526 /**
 527  * @brief Gets the last key event the window gets.
 528  *
 529  * @param[in] window The window instance.
 530  * @return The last key event the window gets.
 531  */
 532 DALI_ADAPTOR_API const KeyEvent& GetLastKeyEvent(Window window);
 533
 534 /**
 535  * @brief Gets the last touch event the window gets.
 536  *
 537  * @param[in] window The window instance.
 538  * @return The last touch event the window gets.
 539  * @note It returns the raw event the window gets. There is no hit-actor and local position information.
 540  */
 541 DALI_ADAPTOR_API const TouchEvent& GetLastTouchEvent(Window window);
 542
 543 /**
 544  * @brief Gets the last hover event the window gets.
 545  *
 546  * @param[in] window The window instance.
 547  * @return The last hover event the window gets.
 548  * @note It returns the raw event the window gets. There is no hit-actor and local position information.
 549  */
 550 DALI_ADAPTOR_API const HoverEvent& GetLastHoverEvent(Window window);
 551
 552 /**
 553  * @brief Sets the pointer constraints lock.
 554  *
 555  * @param[in] window The window instance.
 556  * @return Returns true if PointerConstraintsLock succeeds.
 557  */
 558 DALI_ADAPTOR_API bool PointerConstraintsLock(Window window);
 559
 560 /**
 561  * @brief Sets the pointer constraints unlock.
 562  *
 563  * @param[in] window The window instance.
 564  * @return Returns true if PointerConstraintsUnlock succeeds.
 565  */
 566 DALI_ADAPTOR_API bool PointerConstraintsUnlock(Window window);
 567
 568 /**
 569  * @brief Sets the locked pointer region
 570  *
 571  * @param[in] window The window instance.
 572  * @param[in] x The x position.
 573  * @param[in] y The y position.
 574  * @param[in] width The width.
 575  * @param[in] height The height
 576  */
 577 DALI_ADAPTOR_API void LockedPointerRegionSet(Window window, int32_t x, int32_t y, int32_t width, int32_t height);
 578
 579 /**
 580  * @brief Sets the locked pointer cursor position hintset
 581  *
 582  * @param[in] window The window instance.
 583  * @param[in] x The x position.
 584  * @param[in] y The y position.
 585  */
 586 DALI_ADAPTOR_API void LockedPointerCursorPositionHintSet(Window window, int32_t x, int32_t y);
 587
 588 /**
 589  * @brief Sets the pointer warp. The pointer moves to the set coordinates.
 590  *
 591  * @param[in] window The window instance.
 592  * @param[in] x The x position.
 593  * @param[in] y The y position.
 594  * @return Returns true if PointerWarp succeeds.
 595  */
 596 DALI_ADAPTOR_API bool PointerWarp(Window window, int32_t x, int32_t y);
 597
 598 /**
 599  * @brief Sets visibility on/off of cursor
 600  *
 601  * @param[in] window The window instance.
 602  * @param[in] visible The visibility of cursor
 603  */
 604 DALI_ADAPTOR_API void CursorVisibleSet(Window window, bool visible);
 605
 606 /**
 607  * @brief Requests grab key events according to the requested device subtype
 608  *
 609  * @param[in] window The window instance.
 610  * @param[in] deviceSubclass The deviceSubclass type.
 611  * @return Returns true if KeyboardGrab succeeds.
 612  */
 613 DALI_ADAPTOR_API bool KeyboardGrab(Window window, Device::Subclass::Type deviceSubclass);
 614
 615 /**
 616  * @brief Requests ungrab key events
 617  *
 618  * @param[in] window The window instance.
 619  * @return Returns true if KeyboardUnGrab succeeds.
 620  */
 621 DALI_ADAPTOR_API bool KeyboardUnGrab(Window window);
 622
 623 /**
 624  * @brief Sets full screen sized window.
 625  * If full screen size is set for the window,
 626  * window will be resized with full screen size.
 627  * In addition, the full screen sized window's z-order is the highest.
 628  *
 629  * @param[in] window The window instance.
 630  * @param[in] fullscreen true to set fullscreen, false to unset.
 631  */
 632 DALI_ADAPTOR_API void SetFullScreen(Window window, bool fullscreen);
 633
 634 /**
 635  * @brief Gets whether the full screen sized window or not
 636  *
 637  * @param[in] window The window instance.
 638  * @return Returns true if the full screen sized window is.
 639  */
 640 DALI_ADAPTOR_API bool GetFullScreen(Window window);
 641
 642 /**
 643  * @brief Enables or disables front buffer rendering.
 644  *
 645  * @param[in] window The window instance.
 646  * @param[in] enable true to enable front buffer rendering, false to disable.
 647  */
 648 DALI_ADAPTOR_API void SetFrontBufferRendering(Window window, bool enable);
 649
 650 /**
 651  * @brief Gets whether front buffer rendering is enabled.
 652  *
 653  * @param[in] window The window instance.
 654  * @return Whether front buffer rendering has been enabled or not.
 655  */
 656 DALI_ADAPTOR_API bool GetFrontBufferRendering(Window window);
 657
 658 /**
 659  * @brief The user would connect to this signal to intercept a KeyEvent at window.
 660  *
 661  * Intercepts KeyEvents in the window before dispatching KeyEvents to the control.
 662  * If a KeyEvent is consumed, no KeyEvent is delivered to the control.
 663  *
 664  * @param[in] window The window instance.
 665  * @return The signal to connect to
 666  */
 667 DALI_ADAPTOR_API InterceptKeyEventSignalType& InterceptKeyEventSignal(Window window);
 668
 669 /**
 670  * @brief This signal is emitted when the window is moved.
 671  *
 672  * A callback of the following type may be connected:
 673  * @code
 674  *   void YourCallbackName( Window window, Dali::Window::WindowPosition position );
 675  * @endcode
 676  * The parameters are the moved x and y coordinates.
 677  * and window means this signal was called from what window
 678  *
 679  * @param[in] window The window instance.
 680  * @return The signal to connect to
 681  */
 682 DALI_ADAPTOR_API MovedSignalType& MovedSignal(Window window);
 683
 684 /**
 685  * @brief This signal is emitted when the window orientation is changed.
 686  *
 687  * To emit Window Orientation signal, AddAvailableOrientation() or SetPreferredOrientation() should be called before device is rotated.
 688  * Most of cases, AddAvailableOrientation() or SetPreferredOrientation() is callled in onCreate().
 689  *
 690  * A callback of the following type may be connected:
 691  * @code
 692  *   void YourCallbackName( Window window, Dali::WindowOrientation orientation );
 693  * @endcode
 694  * The parameter is the changed window orientation.
 695  * and window means this signal was called from what window
 696  *
 697  * @param[in] window The window instance.
 698  * @return The signal to connect to
 699  */
 700 DALI_ADAPTOR_API OrientationChangedSignalType& OrientationChangedSignal(Window window);
 701
 702 /**
 703  * @brief This signal is emitted when the mouse in or out event is received.
 704  *
 705  * A callback of the following type may be connected:
 706  * @code
 707  *   void YourCallbackName( Window window, Dali::MouseInOutEvent event );
 708  * @endcode
 709  *
 710  * @param[in] window The window instance.
 711  * @return The signal to connect to
 712  */
 713 DALI_ADAPTOR_API MouseInOutEventSignalType& MouseInOutEventSignal(Window window);
 714
 715 /**
 716  * @brief This signal is emitted when the mouse relative event is received.
 717  *
 718  * A callback of the following type may be connected:
 719  * @code
 720  *   void YourCallbackName( Window window, Dali::MouseRelativeEvent event );
 721  * @endcode
 722  *
 723  * @param[in] window The window instance.
 724  * @return The signal to connect to
 725  */
 726 DALI_ADAPTOR_API MouseRelativeEventSignalType& MouseRelativeEventSignal(Window window);
 727
 728 /**
 729  * @brief This signal is emitted when window has been moved by the display server.
 730  * To make the window move by display server, RequestMoveToServer() should be called.
 731  * After the moving job is completed, this function will be called.
 732  *
 733  * A callback of the following type may be connected:
 734  * @code
 735  *   void YourCallbackName( Window window, Dali::Window::WindowPosition position );
 736  * @endcode
 737  * The parameters are the moved x and y coordinates.
 738  * and window means this signal was called from what window
 739  *
 740  * @param[in] window The window instance.
 741  * @return The signal to connect to
 742  */
 743 DALI_ADAPTOR_API MoveCompletedSignalType& MoveCompletedSignal(Window window);
 744
 745 /**
 746  * @brief This signal is emitted when window has been resized by the display server.
 747  * To make the window move by display server, RequestResizeToServer() should be called.
 748  * After the resizing job is completed, this function will be called.
 749  *
 750  * A callback of the following type may be connected:
 751  * @code
 752  *   void YourCallbackName( Window window, Dali::Window::WindowPosition position );
 753  * @endcode
 754  * The parameters are the resized width and height coordinates.
 755  * and window means this signal was called from what window
 756  *
 757  * @param[in] window The window instance.
 758  * @return The signal to connect to
 759  */
 760 DALI_ADAPTOR_API ResizeCompletedSignalType& ResizeCompletedSignal(Window window);
 761
 762 /**
 763  * @brief This signal is emitted when window insets are changed by appearing or disappearing indicator, virtual keyboard, or clipboard.
 764  *
 765  * @param[in] window The window instance
 766  * @return The signal to connect to
 767  */
 768 DALI_ADAPTOR_API InsetsChangedSignalType& InsetsChangedSignal(Window window);
 769
 770 /**
 771  * @brief This signal is emitted when pointer is locked/unlocked
 772  *
 773  * @param[in] window The window instance
 774  * @return The signal to connect to
 775  */
 776 DALI_ADAPTOR_API PointerConstraintsSignalType& PointerConstraintsSignal(Window window);
 777
 778 } // namespace DevelWindow
 779
 780 } // namespace Dali
 781
 782 #endif // DALI_WINDOW_DEVEL_H