#include "../../events/SDL_windowevents_c.h"
#include <Ecore_Ipc.h>
+#include <Ecore_Wl2.h>
#include <unistd.h>
+#include <string.h>
/*SDL indicator*/
Ecore_Ipc_Server *ipc = NULL;
}
}
+unsigned int
+SDL_Tizen_GetSupportedAuxiliaryHintCount(SDL_Window *window)
+{
+ SDL_WindowData *wind = NULL;
+ Ecore_Wl2_Window *ecore_window = NULL;
+ Eina_List* hints = NULL;
+
+ if (!window || !window->driverdata) {
+ return 0;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ ecore_window = wind->window;
+ if (!ecore_window) {
+ SDL_Log("AddAuxiliaryHint: ecore_window is null");
+ return 0;
+ }
+
+ hints = ecore_wl2_window_aux_hints_supported_get(ecore_window);
+ int count = 0;
+ if (hints) {
+ Eina_List* l = NULL;
+ for (l = hints; l; l = eina_list_next(l)) {
+ count++;
+ }
+ }
+ return count;
+}
+
+const char*
+SDL_Tizen_GetSupportedAuxiliaryHint(SDL_Window *window, unsigned int index)
+{
+ SDL_WindowData *wind = NULL;
+ Ecore_Wl2_Window *ecore_window = NULL;
+ Eina_List* hints = NULL;
+
+ if (!window || !window->driverdata) {
+ return NULL;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ ecore_window = wind->window;
+ if (!ecore_window) {
+ SDL_Log("AddAuxiliaryHint: ecore_window is null");
+ return NULL;
+ }
+
+ hints = ecore_wl2_window_aux_hints_supported_get(ecore_window);
+
+ if (hints) {
+ Eina_List* l = NULL;
+ char* supported_hint = NULL;
+ int i = 0;
+ for (l = hints, (supported_hint = (char*)(eina_list_data_get(l))); l; l = eina_list_next(l), (supported_hint = (char*)(eina_list_data_get(l)))) {
+ if (i == index) {
+ return supported_hint;
+ }
+ i++;
+ }
+ }
+ return NULL;
+}
+
+unsigned int
+SDL_Tizen_AddAuxiliaryHint(SDL_Window *window, const char *hint, const char *value)
+{
+ SDL_WindowData *wind = NULL;
+ Ecore_Wl2_Window *ecore_window = NULL;
+ Eina_List* hints = NULL;
+ SDL_bool supported = SDL_FALSE;
+
+ if (!window || !window->driverdata) {
+ return 0;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ ecore_window = wind->window;
+ if (!ecore_window) {
+ SDL_Log("AddAuxiliaryHint: ecore_window is null");
+ return 0;
+ }
+
+ hints = ecore_wl2_window_aux_hints_supported_get(ecore_window);
+ if (hints) {
+ Eina_List* l = NULL;
+ char* supported_hint = NULL;
+ for (l = hints, (supported_hint = (char*)(eina_list_data_get(l))); l; l = eina_list_next(l),
+ (supported_hint = (char*)(eina_list_data_get(l)))) {
+ if (!SDL_strncmp(supported_hint, hint, strlen(hint))) {
+ supported = SDL_TRUE;
+ break;
+ }
+
+ }
+ }
+
+ if (!supported) {
+ SDL_Log("AddAuxiliaryHint: Not supported auxiliary hint [%s]\n", hint);
+ return 0;
+ }
+
+ unsigned int new_id = 1;
+ if ((wind->auxiliaryHints).auxHintHeader) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ AuxiliaryHint* nextAuxiliaryHint = auxiliaryHint->next;
+ while (auxiliaryHint) {
+ if (!SDL_strncmp(auxiliaryHint->hint, hint, strlen(hint))) {
+ auxiliaryHint->value = value;
+ SDL_Log("AddAuxiliaryHint: Change! hint = %s, value = %s, id = %d\n", auxiliaryHint->hint, auxiliaryHint->value, auxiliaryHint->id);
+ return auxiliaryHint->id;
+ }
+ auxiliaryHint = nextAuxiliaryHint;
+ nextAuxiliaryHint = NULL;
+ if(auxiliaryHint) {
+ nextAuxiliaryHint = auxiliaryHint->next;
+ }
+ new_id++;
+ }
+ }
+
+ // Add the hint
+ AuxiliaryHint* newAuxiliaryHint = (AuxiliaryHint *)SDL_calloc(1, sizeof(AuxiliaryHint));
+ if (!newAuxiliaryHint) {
+ SDL_Log("AddAuxiliaryHint: Fail calloc");
+ return 0;
+ }
+
+ newAuxiliaryHint->id = new_id;
+ newAuxiliaryHint->hint = hint;
+ newAuxiliaryHint->value = value;
+ newAuxiliaryHint->next = NULL;
+ if (new_id != 1) {
+ newAuxiliaryHint->next = (wind->auxiliaryHints).auxHintHeader;
+ }
+
+ (wind->auxiliaryHints).auxHintHeader = newAuxiliaryHint;
+ (wind->auxiliaryHints).size++;
+ ecore_wl2_window_aux_hint_add(ecore_window, (int)new_id, hint, value);
+ SDL_Log("AddAuxiliaryHint: hint = %s, value = %s, id = %d\n", hint, value, new_id);
+
+ return new_id;
+}
+
+SDL_bool
+SDL_Tizen_RemoveAuxiliaryHint(SDL_Window *window, unsigned int id)
+{
+ SDL_WindowData *wind = NULL;
+ Ecore_Wl2_Window *ecore_window = NULL;
+
+ if (!window || !window->driverdata) {
+ return SDL_FALSE;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ ecore_window = wind->window;
+
+ if (!ecore_window) {
+ SDL_Log("RemoveAuxiliaryHint: ecore_window is null");
+ return SDL_FALSE;
+ }
+
+ if (id == 0) {
+ SDL_Log( "RemoveAuxiliaryHint: Invalid id [%d]\n", id );
+ return SDL_FALSE;
+ }
+
+ if ((wind->auxiliaryHints).auxHintHeader) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ AuxiliaryHint* prevAuxiliaryHint = NULL;
+ AuxiliaryHint* nextAuxiliaryHint = auxiliaryHint->next;
+ while (auxiliaryHint) {
+ if (auxiliaryHint->id == id) {
+ SDL_Log("RemoveAuxiliaryHint: id = %d, hint = %s\n", id, auxiliaryHint->hint);
+ ecore_wl2_window_aux_hint_del(ecore_window, (int)id);
+ if (auxiliaryHint == (wind->auxiliaryHints).auxHintHeader) {
+ (wind->auxiliaryHints).auxHintHeader = auxiliaryHint->next;
+ } else {
+ prevAuxiliaryHint->next = nextAuxiliaryHint;
+ }
+ SDL_free(auxiliaryHint);
+ (wind->auxiliaryHints).size--;
+ return SDL_TRUE;
+ }
+ prevAuxiliaryHint = auxiliaryHint;
+ auxiliaryHint = nextAuxiliaryHint;
+ nextAuxiliaryHint = NULL;
+ if(auxiliaryHint) {
+ nextAuxiliaryHint = auxiliaryHint->next;
+ }
+ }
+ }
+ return SDL_FALSE;
+}
+
+SDL_bool
+SDL_Tizen_SetAuxiliaryHint(SDL_Window *window, unsigned int id, const char *value)
+{
+ SDL_WindowData *wind = NULL;
+ Ecore_Wl2_Window *ecore_window = NULL;
+
+ if (!window || !window->driverdata) {
+ return SDL_FALSE;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ ecore_window = wind->window;
+
+ if (!ecore_window) {
+ return SDL_FALSE;
+ }
+
+ if (id == 0) {
+ SDL_Log( "RemoveAuxiliaryHint: Invalid id [%d]\n", id );
+ return SDL_FALSE;
+ }
+
+ if ((wind->auxiliaryHints).auxHintHeader) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ AuxiliaryHint* nextAuxiliaryHint = auxiliaryHint->next;
+ while (auxiliaryHint) {
+ if (auxiliaryHint->id == id) {
+ ecore_wl2_window_aux_hint_change(ecore_window, (int)id, value);
+ auxiliaryHint->value = value;
+ SDL_Log("SetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, auxiliaryHint->hint, auxiliaryHint->value);
+ return SDL_TRUE;
+ }
+ auxiliaryHint = nextAuxiliaryHint;
+ nextAuxiliaryHint = NULL;
+ if(auxiliaryHint) {
+ nextAuxiliaryHint = auxiliaryHint->next;
+ }
+ }
+ }
+ return SDL_FALSE;
+}
+
+const char*
+SDL_Tizen_GetAuxiliaryHintValue(SDL_Window *window, unsigned int id)
+{
+ SDL_WindowData *wind = NULL;
+ if (!window || !window->driverdata) {
+ return NULL;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+ if (id == 0) {
+ SDL_Log( "GetAuxiliaryHintValue: Invalid id [%d]\n", id );
+ return NULL;
+ }
+
+ if ((wind->auxiliaryHints).auxHintHeader) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ while (auxiliaryHint) {
+ if (auxiliaryHint->id == id) {
+ SDL_Log("GetAuxiliaryHintValue: id = %d, hint = %s, value = %s\n", id, auxiliaryHint->hint, auxiliaryHint->value);
+ return auxiliaryHint->value;
+ }
+ auxiliaryHint = auxiliaryHint->next;
+ }
+ }
+ return NULL;
+}
+
+unsigned int
+SDL_Tizen_GetAuxiliaryHintId(SDL_Window *window, const char *hint)
+{
+ SDL_WindowData *wind = NULL;
+ if (!window || !window->driverdata) {
+ return 0;
+ }
+
+ wind = (SDL_WindowData *) window->driverdata;
+
+ if (hint == NULL || (wind->auxiliaryHints).size <= 0) {
+ SDL_Log( "GetAuxiliaryHintId: auxiliaryHints size is 0]\n");
+ return 0;
+ }
+
+ if ((wind->auxiliaryHints).auxHintHeader) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ for (unsigned int i = 0; i < (wind->auxiliaryHints).size; i++) {
+ if (auxiliaryHint->hint == hint) {
+ SDL_Log("GetAuxiliaryHintId: hint = %s, id = %d\n", hint, auxiliaryHint->id);
+ return auxiliaryHint->id;
+ }
+ auxiliaryHint = auxiliaryHint->next;
+ }
+ }
+ SDL_Log("GetAuxiliaryHintId: Invalid hint! [%s]\n", hint);
+
+ return 0;
+}
+
+SDL_bool
+SDL_Tizen_GetWindowAcceptFocus(SDL_Window * window)
+{
+ SDL_WindowData *data = NULL;
+
+ if (!window || !window->driverdata) {
+ return SDL_FALSE;
+ }
+
+ data = (SDL_WindowData *) window->driverdata;
+ if (!data->window) {
+ return SDL_FALSE;
+ }
+
+ return !ecore_wl2_window_focus_skip_get(data->window);
+}
+
+SDL_bool
+SDL_Tizen_SetWindowAcceptFocus(SDL_Window * window, SDL_bool accept)
+{
+ SDL_WindowData *data = NULL;
+
+ if (!window || !window->driverdata) {
+ return SDL_FALSE;
+ }
+
+ data = (SDL_WindowData *) window->driverdata;
+ if (!data->window) {
+ return SDL_FALSE;
+ }
+
+ ecore_wl2_window_focus_skip_set(data->window, !accept);
+ return SDL_TRUE;
+}
+
int
Tizen_CreateWindow(_THIS, SDL_Window *window)
{
if (!wind) {
return SDL_OutOfMemory();
}
-
+ (wind->auxiliaryHints).size = 0;
+ (wind->auxiliaryHints).auxHintHeader = NULL;
window->driverdata = wind;
window->flags |= SDL_WINDOW_INPUT_FOCUS; /* always has input focus */
Tizen_InitKeyboard(_this);
SDL_SetMouseFocus(window);
- if (window->flags & 0x00008000) {
- ecore_wl2_window_input_region_set(wind->window, -1, -1, 1, 1);
- ecore_wl2_window_focus_skip_set(wind->window, EINA_TRUE);
- }
-
EINA_ITERATOR_FOREACH(globals, global) {
if (!strcmp(global->interface, "tizen_policy_ext")) {
wind->rotation_supported = 1;
SDL_WindowData *wind = window->driverdata;
if (data) {
+ AuxiliaryHint* auxiliaryHint = (wind->auxiliaryHints).auxHintHeader;
+ if (auxiliaryHint) {
+ AuxiliaryHint* nextAuxiliaryHints = auxiliaryHint->next;
+ while (auxiliaryHint) {
+ SDL_free(auxiliaryHint);
+ auxiliaryHint = nextAuxiliaryHints;
+ nextAuxiliaryHints = NULL;
+ if (auxiliaryHint) {
+ nextAuxiliaryHints = auxiliaryHint->next;
+ }
+ }
+ }
eina_hash_del(data->windows, &wind->id, window);
#if SDL_VIDEO_OPENGL_EGL
if (window->flags & SDL_WINDOW_OPENGL) {
window->driverdata = NULL;
}
+int
+Tizen_SetWindowOpacity(_THIS, SDL_Window * window, float opacity)
+{
+ SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
+ if (opacity < 1.0f) {
+ ecore_wl2_window_alpha_set(data->window, true);
+ } else {
+ ecore_wl2_window_alpha_set(data->window, false);
+ }
+ return 0;
+}
+
Eina_Bool
_tizen_cb_event_window_visibility_change(void *data, int type, void *event)
{
#include "SDL_syswm.h"
+#include "../../core/tizen/SDL_tizen.h"
#include "SDL_tizenvideo.h"
#include <Ecore_Input.h>
#include <wayland-egl.h>
#include <wayland-egl-tizen.h>
+typedef struct AuxiliaryHint{
+ unsigned int id;
+ const char* hint;
+ const char* value;
+ struct AuxiliaryHint* next;
+}AuxiliaryHint;
+
+typedef struct AuxiliaryHints{
+ AuxiliaryHint* auxHintHeader;
+ int size;
+}AuxiliaryHints;
+
typedef struct {
uint32_t g_res_id; /* Wayland window resource id */
uint32_t id; /* Ecore wayland window id */
SDL_bool support_pre_rotation;
SDL_bool support_indicator;
+ AuxiliaryHints auxiliaryHints;
} SDL_WindowData;
enum tizen_rotation_received_type {
extern void _tizen_quickpanel_on(SDL_WindowData *wind);
extern void _tizen_quickpanel_off(SDL_WindowData *wind);
+/**
+ * \brief Gets the count of supported auxiliary hints of the window.
+ *
+ * \param window SDL_Window
+ * \return The number of supported auxiliary hints.
+ */
+extern TIZEN_INTERNAL_API unsigned int SDL_Tizen_GetSupportedAuxiliaryHintCount(SDL_Window *window);
+
+/**
+ * \brief Gets the supported auxiliary hint string of the window.
+ *
+ * \param window SDL_Window
+ * \param index The index of the supported auxiliary hint lists.
+ * \return The auxiliary hint string of the index.
+ */
+extern TIZEN_INTERNAL_API const char* SDL_Tizen_GetSupportedAuxiliaryHint(SDL_Window *window, unsigned int index);
+
+
+/**
+ * \brief Add a supported auxiliary hint to a given window
+ *
+ * \param window SDL_Window
+ * \param hint The auxiliary hint string.
+ * \param value The value string to be set.
+ * \return The ID of created auxiliary hint, or 0 on failure.
+ */
+extern TIZEN_INTERNAL_API unsigned int SDL_Tizen_AddAuxiliaryHint(SDL_Window *window, const char *hint, const char *value);
+
+/**
+ * \brief Remove an auxiliary hint on a given window
+ *
+ * \param window SDL_Window
+ * \param id The auxiliary hint ID.
+ * \return SDL_TRUE on success, SDL_FALSE on failure.
+ */
+extern TIZEN_INTERNAL_API SDL_bool SDL_Tizen_RemoveAuxiliaryHint(SDL_Window *window, unsigned int id);
+
+/**
+ * \brief Change an auxiliary hint on a given window
+ *
+ * \param window SDL_Window
+ * \param id The auxiliary hint ID.
+ * \param value The value string to be set.
+ * \return SDL_TRUE on success, SDL_FALSE on failure.
+ */
+extern TIZEN_INTERNAL_API SDL_bool SDL_Tizen_SetAuxiliaryHint(SDL_Window *window, unsigned int id, const char *value);
+
+/**
+ * \brief Gets a value of the auxiliary hint.
+ *
+ * \param window SDL_Window
+ * \param id The auxiliary hint ID
+ * \return The string value of the auxiliary hint ID, or an empty string if none exists.
+ */
+extern TIZEN_INTERNAL_API const char* SDL_Tizen_GetAuxiliaryHintValue(SDL_Window *window, unsigned int id);
+
+/**
+ * \brief Gets an ID of the auxiliary hint string.
+ *
+ * \param window SDL_Window
+ * \param hint The auxiliary hint string.
+ * \return The ID of auxiliary hint string, or 0 on failure.
+ */
+extern TIZEN_INTERNAL_API unsigned int SDL_Tizen_GetAuxiliaryHintId(SDL_Window *window, const char *hint);
+
+/**
+ * \brief Sets whether the window accepts a focus or not.
+ *
+ * \param window SDL_Window
+ * \param accept If a focus is accepted or not. The default is true.
+ * \return SDL_TRUE on success, SDL_FALSE on failure.
+ */
+extern TIZEN_INTERNAL_API SDL_bool SDL_Tizen_SetWindowAcceptFocus(SDL_Window * window, SDL_bool accept);
+
+/**
+ * \brief Returns whether the window accepts a focus or not.
+ *
+ * \param window SDL_Window
+ * \return True if the window accepts a focus, false otherwise.
+ */
+extern TIZEN_INTERNAL_API SDL_bool SDL_Tizen_GetWindowAcceptFocus(SDL_Window * window);
+
#endif /* _SDL_tizenwindow_h */
/* vi: set ts=4 sw=4 expandtab: */
projects / platform / upstream / SDL.git / commitdiff