1 #ifndef DALI_GL_WINDOW_H
2 #define DALI_GL_WINDOW_H
5 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include <dali/public-api/adaptor-framework/window-enumerations.h>
23 #include <dali/public-api/math/rect.h>
24 #include <dali/public-api/math/uint-16-pair.h>
25 #include <dali/public-api/math/vector2.h>
26 #include <dali/public-api/math/vector4.h>
27 #include <dali/public-api/object/any.h>
28 #include <dali/public-api/object/base-handle.h>
29 #include <dali/public-api/signals/dali-signal.h>
33 #include <dali/public-api/dali-adaptor-common.h>
38 * @addtogroup dali_adaptor_framework
42 typedef Dali::Rect<int> PositionSize;
44 namespace Internal DALI_INTERNAL
50 } // namespace DALI_INTERNAL
56 * @brief The GlWindow class is to draw with native GLES.
58 * This class is the special window. It is for native GLES application.
59 * So, some special funtions and type are supported.
60 * In addition, basic window's functions are supported, too.
63 class DALI_ADAPTOR_API GlWindow : public BaseHandle
66 using WindowSize = Uint16Pair;
68 typedef Signal<void(const KeyEvent&)> KeyEventSignalType; ///< GlWindow Key Event signal type
69 typedef Signal<void(const TouchEvent&)> TouchEventSignalType; ///< GlWindow Touch Event signal type
70 typedef Signal<void(GlWindow, bool)> FocusChangeSignalType; ///< GlWindow Focus signal type
71 typedef Signal<void(WindowSize)> ResizeSignalType; ///< GlWindow resize signal type
72 typedef Signal<void(GlWindow, bool)> VisibilityChangedSignalType; ///< GlWindow visibility change signal type
78 * @brief Enumeration for GLES verion
80 * This Enumeration is used the GLES version for EGL configuration.
81 * If the device can not support GLES version 3.0 over, the version will be chosen with GLES version 2.0
84 enum class GlesVersion
86 VERSION_2_0 = 0, ///< GLES version 2.0
87 VERSION_3_0, ///< GLES version 3.0
91 * @brief Enumeration for rendering mode
93 * This Enumeration is used to choose the rendering mode.
95 * One of them is continuous mode. It is rendered continuously.
96 * The other is on demand mode. It is rendered by application.
98 enum class RenderingMode
100 CONTINUOUS, ///< continuous mode
101 ON_DEMAND ///< on demand by application
105 * @brief Creates an initialized handle to a new GlWindow.
107 * @return A new GlWindow
108 * @note This creates an extra GlWindow in addition to the default main GlWindow
110 static GlWindow New();
113 * @brief Creates an initialized handle to a new GlWindow.
115 * @param[in] positionSize The position and size of the GlWindow
116 * @param[in] name The GlWindow title
117 * @param[in] className The GlWindow class name
118 * @param[in] isTransparent Whether GlWindow is transparent
119 * @note This creates an extra GlWindow in addition to the default main GlWindow
120 * @return A new GlWindow
122 static GlWindow New(PositionSize positionSize, const std::string& name, const std::string& className, bool isTransparent = false);
125 * @brief Creates an uninitialized handle.
127 * This can be initialized using Dali::Application::GetGlWindow() or
128 * Dali::GlWindow::New().
136 * This is non-virtual since derived Handle types must not contain data or virtual methods.
142 * @brief This copy constructor is required for (smart) pointer semantics.
144 * @param[in] handle A reference to the copied handle
146 GlWindow(const GlWindow& handle);
149 * @brief This assignment operator is required for (smart) pointer semantics.
151 * @param[in] rhs A reference to the copied handle
152 * @return A reference to this
154 GlWindow& operator=(const GlWindow& rhs);
157 * @brief Move constructor.
159 * @param[in] rhs A reference to the moved handle
161 GlWindow(GlWindow&& rhs);
164 * @brief Move assignment operator.
166 * @param[in] rhs A reference to the moved handle
167 * @return A reference to this handle
169 GlWindow& operator=(GlWindow&& rhs);
172 * @brief Sets egl configuration for GlWindow
174 * @param[in] depth the flag of depth buffer. If true is set, 24bit depth buffer is enabled.
175 * @param[in] stencil the flag of stencil. it true is set, 8bit stencil buffer is enabled.
176 * @param[in] msaa the bit of msaa.
177 * @param[in] version the GLES version
180 void SetEglConfig(bool depth, bool stencil, int msaa, GlesVersion version);
183 * @brief Raises GlWindow to the top of GlWindow stack.
189 * @brief Lowers GlWindow to the bottom of GlWindow stack.
195 * @brief Activates GlWindow to the top of GlWindow stack even it is iconified.
201 * @brief Shows the GlWindow if it is hidden.
207 * @brief Hides the GlWindow if it is showing.
213 * @brief Sets a position of the GlWindow.
215 * @param[in] positionSize The new GlWindow position
217 void SetPositionSize(PositionSize positionSize);
220 * @brief Gets a position of the GlWindow.
222 * @return The position of the GlWindow
224 PositionSize GetPositionSize() const;
227 * @brief Gets the count of supported auxiliary hints of the window.
229 * @return The number of supported auxiliary hints.
231 * @note The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the window manager.
232 * If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints.
234 unsigned int GetSupportedAuxiliaryHintCount() const;
237 * @brief Gets the supported auxiliary hint string of the window.
239 * @param[in] index The index of the supported auxiliary hint lists
240 * @return The auxiliary hint string of the index.
242 * @note The window auxiliary hint is the value which is used to decide which actions should be made available to the user by the window manager.
243 * If you want to set specific hint to your window, then you should check whether it exists in the supported auxiliary hints.
245 std::string GetSupportedAuxiliaryHint(unsigned int index) const;
248 * @brief Creates an auxiliary hint of the window.
250 * @param[in] hint The auxiliary hint string.
251 * @param[in] value The value string.
252 * @return The ID of created auxiliary hint, or @c 0 on failure.
254 unsigned int AddAuxiliaryHint(const std::string& hint, const std::string& value);
257 * @brief Removes an auxiliary hint of the window.
259 * @param[in] id The ID of the auxiliary hint.
260 * @return True if no error occurred, false otherwise.
262 bool RemoveAuxiliaryHint(unsigned int id);
265 * @brief Changes a value of the auxiliary hint.
267 * @param[in] id The auxiliary hint ID.
268 * @param[in] value The value string to be set.
269 * @return True if no error occurred, false otherwise.
271 bool SetAuxiliaryHintValue(unsigned int id, const std::string& value);
274 * @brief Gets a value of the auxiliary hint.
276 * @param[in] id The auxiliary hint ID.
277 * @return The string value of the auxiliary hint ID, or an empty string if none exists.
279 std::string GetAuxiliaryHintValue(unsigned int id) const;
282 * @brief Gets a ID of the auxiliary hint string.
284 * @param[in] hint The auxiliary hint string.
285 * @return The ID of the auxiliary hint string, or @c 0 if none exists.
287 unsigned int GetAuxiliaryHintId(const std::string& hint) const;
290 * @brief Sets a region to accept input events.
292 * @param[in] inputRegion The region to accept input events.
294 void SetInputRegion(const Rect<int>& inputRegion);
297 * @brief Sets a transparent window's visual state to opaque.
298 * @details If a visual state of a transparent window is opaque,
299 * then the window manager could handle it as an opaque window when calculating visibility.
301 * @param[in] opaque Whether the window's visual state is opaque.
302 * @remarks This will have no effect on an opaque window.
303 * It doesn't change transparent window to opaque window but lets the window manager know the visual state of the window.
305 void SetOpaqueState(bool opaque);
308 * @brief Returns whether a transparent window's visual state is opaque or not.
310 * @return True if the window's visual state is opaque, false otherwise.
311 * @remarks The return value has no meaning on an opaque window.
313 bool IsOpaqueState() const;
316 * @brief Gets current rotation angle of the window.
318 * @return The current GlWindow rotation angle if previously set, or none
320 WindowOrientation GetCurrentOrientation() const;
323 * @brief Sets available orientations of the window.
325 * This API is for setting several orientations one time.
327 * @param[in] orientations The available orientations list to add
329 void SetAvailableOrientations(const Dali::Vector<WindowOrientation>& orientations);
332 * @brief Sets a preferred orientation.
334 * @param[in] orientation The preferred orientation
335 * @pre angle is in the list of available orientation.
337 * @note To unset the preferred orientation, angle should be set NO_ORIENTATION_PREFERENCE.
339 void SetPreferredOrientation(WindowOrientation orientation);
342 * @brief Registers a GL callback function for application.
344 * @param[in] initCallback the callback function for application initialize
345 * @param[in] renderFrameCallback the callback function to render for the frame.
346 * @param[in] terminateCallback the callback function to clean-up application GL resource.
348 * @note Function must be called on idle time
350 * A initCallback of the following type should be used:
352 * void intializeGL();
354 * This callback will be called before renderFrame callback is called at once.
356 * A renderFrameCallback of the following type should be used:
358 * int renderFrameGL();
360 * This callback's return value is not 0, the eglSwapBuffers() will be called.
362 * A terminateCallback of the following type should be used:
364 * void terminateGL();
366 * This callback is called when GlWindow is deleted.
368 void RegisterGlCallback(CallbackBase* initCallback, CallbackBase* renderFrameCallback, CallbackBase* terminateCallback);
371 * @brief Renders once more even if GL render functions are not added to idler.
372 * @note Will not work if the window is hidden or GL render functions are added to idler
378 * @brief Sets rendering mode.
380 * @param[in] mode the rendering mode for GlWindow
382 * @note The default Rendering mode is continuous.
383 * If OnDemand mode is set, it is rendered by RenderOnce()
385 void SetRenderingMode(RenderingMode mode);
388 * @brief Gets rendering mode.
390 * @return current rendering mode in this GlWindow
392 * @note The default Rendering mode is continuous.
393 * If OnDemand mode is set, it is rendered by RenderOnce()
395 RenderingMode GetRenderingMode() const;
399 * @brief The user should connect to this signal to get a timing when GlWindow gains focus or loses focus.
401 * A callback of the following type may be connected:
403 * void YourCallbackName( GlWindow GlWindow, bool focusIn );
405 * The parameter is true if GlWindow gains focus, otherwise false.
406 * and GlWindow means this signal was called from what GlWindow
408 * @return The signal to connect to
410 FocusChangeSignalType& FocusChangeSignal();
413 * @brief This signal is emitted when the GlWindow is resized.
415 * A callback of the following type may be connected:
417 * void YourCallbackName( GlWindow GlWindow, int width, int height );
419 * The parameters are the resized width and height.
420 * and GlWindow means this signal was called from what GlWindow
422 * @return The signal to connect to
424 ResizeSignalType& ResizeSignal();
427 * @brief This signal is emitted when key event is received.
429 * A callback of the following type may be connected:
431 * void YourCallbackName(const KeyEvent& event);
434 * @return The signal to connect to
436 KeyEventSignalType& KeyEventSignal();
439 * @brief This signal is emitted when the screen is touched and when the touch ends
440 * (i.e. the down & up touch events only).
442 * If there are multiple touch points, then this will be emitted when the first touch occurs and
443 * then when the last finger is lifted.
444 * An interrupted event will also be emitted (if it occurs).
445 * A callback of the following type may be connected:
447 * void YourCallbackName(const TouchEvent& event);
450 * @return The touch signal to connect to
452 * @note Motion events are not emitted.
454 TouchEventSignalType& TouchedSignal();
457 * @brief This signal is emitted when the window is shown or hidden.
459 * A callback of the following type may be connected:
461 * void YourCallbackName( Window window, bool visible );
464 * @return The signal to connect to
466 VisibilityChangedSignalType& VisibilityChangedSignal();
468 public: // Not intended for application developers
471 * @brief This constructor is used by Dali::Application::GetGlWindow().
472 * @param[in] GlWindow A pointer to the GlWindow
474 explicit DALI_INTERNAL GlWindow(Internal::Adaptor::GlWindow* GlWindow);
483 #endif // DALI_GL_WINDOW_H