#define E_COMP_WL
-
#include "e.h"
#include "e_mod_main_wl.h"
-#include "protocol/keyrouter-protocol.h"
#include <string.h>
static int _e_keyrouter_find_duplicated_client(E_Client *ec, struct wl_client *wc, uint32_t key, uint32_t mode);
E_Pixmap *ep = NULL;
E_Client *ec = NULL;
- int res = WL_KEYROUTER_ERROR_NONE;
+ int res = TIZEN_KEYROUTER_ERROR_NONE;
if (surface)
{
if (!(ep = wl_resource_get_user_data(surface)))
{
KLDBG("Surface is valid and e_pixmap pointer from the surface is invalid ! Return error !\n");
- return WL_KEYROUTER_ERROR_INVALID_SURFACE;
+ return TIZEN_KEYROUTER_ERROR_INVALID_SURFACE;
}
if (!(ec = e_pixmap_client_get(ep)))
{
KLDBG("e_client pointer from e_pixmap pointer from surface is invalid ! Return error !\n");
- return WL_KEYROUTER_ERROR_INVALID_SURFACE;
+ return TIZEN_KEYROUTER_ERROR_INVALID_SURFACE;
}
}
switch(mode)
{
- case WL_KEYROUTER_MODE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
if (krt->HardKeys[key].excl_ptr)
{
KLDBG("key(%d) is already exclusive grabbed\n", key);
- return WL_KEYROUTER_ERROR_GRABBED_ALREADY;
+ return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
}
if (ec)
{
break;
- case WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
if (ec)
{
res = e_keyrouter_prepend_to_keylist(ec, NULL, key, mode);
KLDBG("Succeed to set keygrab information (E_Client:%p, key:%d, mode:OR_EXCLUSIVE)\n", ec, key);
break;
- case WL_KEYROUTER_MODE_TOPMOST:
+ case TIZEN_KEYROUTER_MODE_TOPMOST:
res = e_keyrouter_prepend_to_keylist(ec, NULL, key, mode);
CHECK_ERR_VAL(res);
KLDBG("Succeed to set keygrab information (E_Client:%p, key:%d, mode:TOPMOST)\n", ec, key);
break;
- case WL_KEYROUTER_MODE_SHARED:
+ case TIZEN_KEYROUTER_MODE_SHARED:
if (ec)
{
res = e_keyrouter_prepend_to_keylist(ec, NULL, key, mode);
default:
KLDBG("Unknown key(%d) grab mode(%d)\n", key, mode);
- return WL_KEYROUTER_ERROR_INVALID_MODE;
+ return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
}
//KLDBG("krt->HardKeys[%d].keycode: %d\n", key, krt->HardKeys[key].keycode);
- return WL_KEYROUTER_ERROR_NONE;
+ return TIZEN_KEYROUTER_ERROR_NONE;
}
switch(mode)
{
- case WL_KEYROUTER_MODE_EXCLUSIVE:
- return WL_KEYROUTER_ERROR_NONE;
+ case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
+ return TIZEN_KEYROUTER_ERROR_NONE;
- case WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
keylist_ptr = krt->HardKeys[key].or_excl_ptr;
break;
- case WL_KEYROUTER_MODE_TOPMOST:
+ case TIZEN_KEYROUTER_MODE_TOPMOST:
keylist_ptr = krt->HardKeys[key].top_ptr;
break;
- case WL_KEYROUTER_MODE_SHARED:
+ case TIZEN_KEYROUTER_MODE_SHARED:
keylist_ptr = krt->HardKeys[key].shared_ptr;
break;
- case WL_KEYROUTER_MODE_PRESSED:
+ case TIZEN_KEYROUTER_MODE_PRESSED:
keylist_ptr = krt->HardKeys[key].press_ptr;
break;
default:
KLDBG("Unknown key(%d) and grab mode(%d)\n", key, mode);
- return WL_KEYROUTER_ERROR_INVALID_MODE;
+ return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
}
EINA_LIST_FOREACH(keylist_ptr, l, key_node_data)
if (key_node_data->ec == ec)
{
KLDBG("The key(%d) is already grabbed same mode(%d) on the same E_Client(%p)\n", key, mode, ec);
- return WL_KEYROUTER_ERROR_GRABBED_ALREADY;
+ return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
}
}
else
if (key_node_data->wc == wc)
{
KLDBG("The key(%d) is already grabbed same mode(%d) on the same Wl_Client(%p)\n", key, mode, wc);
- return WL_KEYROUTER_ERROR_GRABBED_ALREADY;
+ return TIZEN_KEYROUTER_ERROR_GRABBED_ALREADY;
}
}
}
}
- return WL_KEYROUTER_ERROR_NONE;
+ return TIZEN_KEYROUTER_ERROR_NONE;
}
/* Function for prepending a new key grab information in the keyrouting list */
int
e_keyrouter_prepend_to_keylist(E_Client *ec, struct wl_client *wc, uint32_t key, uint32_t mode)
{
- int res = WL_KEYROUTER_ERROR_NONE;
+ int res = TIZEN_KEYROUTER_ERROR_NONE;
res = _e_keyrouter_find_duplicated_client(ec, wc, key, mode);
CHECK_ERR_VAL(res);
if (!new_keyptr)
{
KLDBG("Failled to allocate memory for new_keyptr\n");
- return WL_KEYROUTER_ERROR_NO_SYSTEM_RESOURCES;
+ return TIZEN_KEYROUTER_ERROR_NO_SYSTEM_RESOURCES;
}
new_keyptr->ec = ec;
switch(mode)
{
- case WL_KEYROUTER_MODE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
krt->HardKeys[key].excl_ptr = eina_list_prepend(krt->HardKeys[key].excl_ptr, new_keyptr);
if (ec)
}
break;
- case WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
krt->HardKeys[key].or_excl_ptr= eina_list_prepend(krt->HardKeys[key].or_excl_ptr, new_keyptr);
if (ec)
{
- KLDBG("WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
+ KLDBG("TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
}
else
{
- KLDBG("WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
+ KLDBG("TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
}
break;
- case WL_KEYROUTER_MODE_TOPMOST:
+ case TIZEN_KEYROUTER_MODE_TOPMOST:
krt->HardKeys[key].top_ptr = eina_list_prepend(krt->HardKeys[key].top_ptr, new_keyptr);
if (ec)
{
- KLDBG("WL_KEYROUTER_MODE_TOPMOST, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
+ KLDBG("TIZEN_KEYROUTER_MODE_TOPMOST, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
}
else
{
- KLDBG("WL_KEYROUTER_MODE_TOPMOST, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
+ KLDBG("TIZEN_KEYROUTER_MODE_TOPMOST, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
}
break;
- case WL_KEYROUTER_MODE_SHARED:
+ case TIZEN_KEYROUTER_MODE_SHARED:
krt->HardKeys[key].shared_ptr= eina_list_prepend(krt->HardKeys[key].shared_ptr, new_keyptr);
if (ec)
{
- KLDBG("WL_KEYROUTER_MODE_SHARED, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
+ KLDBG("TIZEN_KEYROUTER_MODE_SHARED, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
}
else
{
- KLDBG("WL_KEYROUTER_MODE_SHARED, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
+ KLDBG("TIZEN_KEYROUTER_MODE_SHARED, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
}
break;
- case WL_KEYROUTER_MODE_PRESSED:
+ case TIZEN_KEYROUTER_MODE_PRESSED:
krt->HardKeys[key].press_ptr = eina_list_prepend(krt->HardKeys[key].press_ptr, new_keyptr);
if (ec)
{
- KLDBG("WL_KEYROUTER_MODE_PRESSED, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
+ KLDBG("TIZEN_KEYROUTER_MODE_PRESSED, key=%d, e_client(%p), wl_client(NULL) has been set !\n", key, ec);
}
else
{
- KLDBG("WL_KEYROUTER_MODE_PRESSED, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
+ KLDBG("TIZEN_KEYROUTER_MODE_PRESSED, key=%d, e_client(NULL), wl_client(%p) has been set !\n", key, wc);
}
break;
default:
KLDBG("Unknown key(%d) and grab mode(%d)\n", key, mode);
E_FREE(new_keyptr);
- return WL_KEYROUTER_ERROR_INVALID_MODE;
+ return TIZEN_KEYROUTER_ERROR_INVALID_MODE;
}
- if ( (wc) && (mode != WL_KEYROUTER_MODE_PRESSED) )
+ if ( (wc) && (mode != TIZEN_KEYROUTER_MODE_PRESSED) )
{
KLDBG("Add a client(%p) destory listener\n", wc);
e_keyrouter_add_client_destroy_listener(wc);
/* TODO: if failed add client_destory_listener, remove keygrabs */
}
- return WL_KEYROUTER_ERROR_NONE;
+ return TIZEN_KEYROUTER_ERROR_NONE;
}
#define E_KEYROUTER_REMOVE_KEY_NODE_IN_LIST(list, ec, wc, l, l_next, key_node_data, key, mode_str) \
switch (mode)
{
- case WL_KEYROUTER_MODE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_EXCLUSIVE:
E_KEYROUTER_REMOVE_KEY_NODE_IN_LIST(krt->HardKeys[key].excl_ptr, ec, wc, l, l_next, key_node_data, key, "Exclusive");
break;
- case WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
+ case TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE:
E_KEYROUTER_REMOVE_KEY_NODE_IN_LIST(krt->HardKeys[key].or_excl_ptr, ec, wc, l, l_next, key_node_data, key, "OR_Exclusive");
break;
- case WL_KEYROUTER_MODE_TOPMOST:
+ case TIZEN_KEYROUTER_MODE_TOPMOST:
E_KEYROUTER_REMOVE_KEY_NODE_IN_LIST(krt->HardKeys[key].top_ptr, ec, wc, l, l_next, key_node_data, key, "Top Position");
break;
- case WL_KEYROUTER_MODE_SHARED:
+ case TIZEN_KEYROUTER_MODE_SHARED:
E_KEYROUTER_REMOVE_KEY_NODE_IN_LIST(krt->HardKeys[key].shared_ptr, ec, wc, l, l_next, key_node_data, key, "Shared");
break;
}
/* exclusive grab */
- e_keyrouter_find_and_remove_client_from_list(ec, wc, index, WL_KEYROUTER_MODE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(ec, wc, index, TIZEN_KEYROUTER_MODE_EXCLUSIVE);
/* or exclusive grab */
- e_keyrouter_find_and_remove_client_from_list(ec, wc, index, WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(ec, wc, index, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
/* top position grab */
- e_keyrouter_find_and_remove_client_from_list(ec, wc, index, WL_KEYROUTER_MODE_TOPMOST);
+ e_keyrouter_find_and_remove_client_from_list(ec, wc, index, TIZEN_KEYROUTER_MODE_TOPMOST);
/* shared grab */
- e_keyrouter_find_and_remove_client_from_list(ec, wc, index, WL_KEYROUTER_MODE_SHARED);
+ e_keyrouter_find_and_remove_client_from_list(ec, wc, index, TIZEN_KEYROUTER_MODE_SHARED);
}
}
\ No newline at end of file
#define E_COMP_WL
#include "e.h"
#include "e_mod_main_wl.h"
-#include <tizen-extension-server-protocol.h>
#include <string.h>
E_KeyrouterPtr krt = NULL;
static void _e_keyrouter_wl_client_cb_destroy(struct wl_listener *l, void *data);
-/* wl_keyrouter_set_keygrab request handler */
+/* tizen_keyrouter_set_keygrab request handler */
static void
_e_keyrouter_cb_keygrab_set(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key, uint32_t mode)
{
if (!surface)
{
/* Regarding topmost mode, a client must request to grab a key with a valid surface. */
- if (mode == WL_KEYROUTER_MODE_TOPMOST)
+ if (mode == TIZEN_KEYROUTER_MODE_TOPMOST)
{
KLDBG("Invalid surface for TOPMOST grab mode ! (key=%d, mode=%d)\n", key, mode);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, WL_KEYROUTER_ERROR_INVALID_SURFACE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_INVALID_SURFACE);
}
else
{
if (0 > key || MAX_HWKEYS < key )
{
KLDBG("Invalid range of key ! (keycode:%d)\n", key);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, WL_KEYROUTER_ERROR_INVALID_KEY);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_INVALID_KEY);
}
/* Check whether the key can be grabbed or not !
if (0 == krt->HardKeys[key].keycode)
{
KLDBG("Invalid key ! Disabled to grab ! (keycode:%d)\n", key);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, WL_KEYROUTER_ERROR_INVALID_KEY);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_INVALID_KEY);
}
/* Check whether the mode is valid or not */
- if (WL_KEYROUTER_MODE_NONE > mode || WL_KEYROUTER_MODE_EXCLUSIVE < mode)
+ if (TIZEN_KEYROUTER_MODE_NONE > mode || TIZEN_KEYROUTER_MODE_EXCLUSIVE < mode)
{
KLDBG("Invalid range of mode ! (mode:%d)\n", mode);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, WL_KEYROUTER_ERROR_INVALID_MODE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, TIZEN_KEYROUTER_ERROR_INVALID_MODE);
}
/* Check whether the request key can be grabbed or not */
WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, mode, res);
}
-/* wl_keyrouter unset_keygrab request handler */
+/* tizen_keyrouter unset_keygrab request handler */
static void
_e_keyrouter_cb_keygrab_unset(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key)
{
if (!surface)
{
/* EXCLUSIVE grab */
- e_keyrouter_find_and_remove_client_from_list(NULL, client, key, WL_KEYROUTER_MODE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(NULL, client, key, TIZEN_KEYROUTER_MODE_EXCLUSIVE);
/* OVERRIDABLE_EXCLUSIVE grab */
- e_keyrouter_find_and_remove_client_from_list(NULL, client, key, WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(NULL, client, key, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
/* TOPMOST(TOP_POSITION) grab */
- e_keyrouter_find_and_remove_client_from_list(NULL, client, key, WL_KEYROUTER_MODE_TOPMOST);
+ e_keyrouter_find_and_remove_client_from_list(NULL, client, key, TIZEN_KEYROUTER_MODE_TOPMOST);
/* SHARED grab */
- e_keyrouter_find_and_remove_client_from_list(NULL, client, key, WL_KEYROUTER_MODE_SHARED);
+ e_keyrouter_find_and_remove_client_from_list(NULL, client, key, TIZEN_KEYROUTER_MODE_SHARED);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_NONE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_NONE);
}
if (!surface || !(ep = wl_resource_get_user_data(surface)))
{
KLDBG("Surface or E_Pixman from the surface is invalid ! Return error !\n");
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_INVALID_SURFACE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_INVALID_SURFACE);
}
if (!(ec = e_pixmap_client_get(ep)))
{
KLDBG("E_Client pointer from E_Pixman from surface is invalid ! Return error !\n");
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_INVALID_SURFACE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_INVALID_SURFACE);
}
/* EXCLUSIVE grab */
- e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, WL_KEYROUTER_MODE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, TIZEN_KEYROUTER_MODE_EXCLUSIVE);
/* OVERRIDABLE_EXCLUSIVE grab */
- e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, WL_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
+ e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, TIZEN_KEYROUTER_MODE_OVERRIDABLE_EXCLUSIVE);
/* TOPMOST(TOP_POSITION) grab */
- e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, WL_KEYROUTER_MODE_TOPMOST);
+ e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, TIZEN_KEYROUTER_MODE_TOPMOST);
/* SHARED grab */
- e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, WL_KEYROUTER_MODE_SHARED);
+ e_keyrouter_find_and_remove_client_from_list(ec, NULL, key, TIZEN_KEYROUTER_MODE_SHARED);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_NONE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_NONE);
}
-/* wl_keyrouter get_keygrab_status request handler */
+/* tizen_keyrouter get_keygrab_status request handler */
static void
_e_keyrouter_cb_get_keygrab_status(struct wl_client *client, struct wl_resource *resource, struct wl_resource *surface, uint32_t key)
{
/* Regarding exclusive mode, a client can request to grab a key without a surface.
* TODO : Need to check the (grab) mode */
#if 0
- if (mode < WL_KEYROUTER_MODE_EXCLUSIVE)
+ if (mode < TIZEN_KEYROUTER_MODE_EXCLUSIVE)
{
KLDBG("Invalid surface ! (key=%d, mode=%d)\n", key, mode);
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_INVALID_SURFACE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_INVALID_SURFACE);
return;
}
else
/* TODO : Need to check key grab status for the requesting wl client */
- WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, WL_KEYROUTER_MODE_NONE, WL_KEYROUTER_ERROR_NONE);
+ WL_KEYGRAB_NOTIFY_WITH_VAL(resource, surface, key, TIZEN_KEYROUTER_MODE_NONE, TIZEN_KEYROUTER_ERROR_NONE);
}
/* Function for registering wl_client destroy listener */
if (wc_data == client)
{
KLDBG("client(%p)'s destroy listener is already added, wc_data(%p)\n", client, wc_data);
- return WL_KEYROUTER_ERROR_NONE;
+ return TIZEN_KEYROUTER_ERROR_NONE;
}
}
}
if (!destroy_listener)
{
KLDBG("Failed to allocate memory for wl_client destroy listener !\n");
- return WL_KEYROUTER_ERROR_NO_SYSTEM_RESOURCES;
+ return TIZEN_KEYROUTER_ERROR_NO_SYSTEM_RESOURCES;
}
destroy_listener->notify = _e_keyrouter_wl_client_cb_destroy;
KLDBG("Add a wl_client(%p) destroy listener(%p)\n", client, destroy_listener);
- return WL_KEYROUTER_ERROR_NONE;
+ return TIZEN_KEYROUTER_ERROR_NONE;
}
-static const struct wl_keyrouter_interface _e_keyrouter_implementation = {
+static const struct tizen_keyrouter_interface _e_keyrouter_implementation = {
_e_keyrouter_cb_keygrab_set,
_e_keyrouter_cb_keygrab_unset,
_e_keyrouter_cb_get_keygrab_status
};
-/* wl_keyrouter global object destroy function */
+/* tizen_keyrouter global object destroy function */
static void
_e_keyrouter_cb_destory(struct wl_resource *resource)
{
/* TODO : destroy resources if exist */
}
-/* wl_keyrouter global object bind function */
+/* tizen_keyrouter global object bind function */
static void
_e_keyrouter_cb_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
{
E_KeyrouterPtr krt_instance = data;
struct wl_resource *resource;
- resource = wl_resource_create(client, &wl_keyrouter_interface, MIN(version, 1), id);
+ resource = wl_resource_create(client, &tizen_keyrouter_interface, MIN(version, 1), id);
- KLDBG("wl_resource_create(...,&wl_keyrouter_interface,...)\n");
+ KLDBG("wl_resource_create(...,&tizen_keyrouter_interface,...)\n");
if (!resource)
{
if (ECORE_EVENT_KEY_DOWN == type)
{
- e_keyrouter_prepend_to_keylist(ec, wc, ev->keycode, WL_KEYROUTER_MODE_PRESSED);
+ e_keyrouter_prepend_to_keylist(ec, wc, ev->keycode, TIZEN_KEYROUTER_MODE_PRESSED);
evtype = WL_KEYBOARD_KEY_STATE_PRESSED;
}
else
}
krt->cdata = cdata;
- krt->global = wl_global_create(cdata->wl.disp, &wl_keyrouter_interface, 1, krt, _e_keyrouter_cb_bind);
+ krt->global = wl_global_create(cdata->wl.disp, &tizen_keyrouter_interface, 1, krt, _e_keyrouter_cb_bind);
if (!krt->global)
{
#ifndef E_MOD_MAIN_H
#define E_MOD_MAIN_H
+#include <tizen-extension-server-protocol.h>
+
/* Temporary value of maximum number of HWKeys */
#define MAX_HWKEYS 512
-#define CHECK_ERR(val) if (WL_KEYROUTER_ERROR_NONE != val) return;
-#define CHECK_ERR_VAL(val) if (WL_KEYROUTER_ERROR_NONE != val) return val;
+#define CHECK_ERR(val) if (TIZEN_KEYROUTER_ERROR_NONE != val) return;
+#define CHECK_ERR_VAL(val) if (TIZEN_KEYROUTER_ERROR_NONE != val) return val;
#define CHECK_NULL(val) if (!val) return;
#define CHECK_NULL_VAL(val) if (!val) return val;
-#define KLDBG(msg, ARG...) DBG("[wl_keyrouter][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG)
+#define KLDBG(msg, ARG...) DBG("[tizen_keyrouter][%s:%d] "msg, __FUNCTION__, __LINE__, ##ARG)
#define WL_KEYGRAB_NOTIFY_WITH_VAL(resource,surface,key,mode,err) \
- wl_keyrouter_send_keygrab_notify(resource, surface, key, mode, err); \
+ tizen_keyrouter_send_keygrab_notify(resource, surface, key, mode, err); \
return
typedef struct _E_Keyrouter E_Keyrouter;
typedef struct _E_Keyrouter_Tizen_HWKey E_Keyrouter_Tizen_HWKey;
typedef struct _E_Keyrouter_Grabbed_Key E_Keyrouter_Grabbed_Key;
-#define WL_KEYROUTER_MODE_PRESSED WL_KEYROUTER_MODE_EXCLUSIVE+1
+#define TIZEN_KEYROUTER_MODE_PRESSED TIZEN_KEYROUTER_MODE_EXCLUSIVE+1
extern E_KeyrouterPtr krt;
projects / platform / core / uifw / e-mod-tizen-keyrouter.git / commitdiff