dimmus
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
efl/src/lib/efl_canvas_wl/copiedfromweston.x

414 lines
13 KiB
Plaintext
Raw Blame History

/*
* Copyright © 2011 Kristian Høgsberg
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#define ALL_ACTIONS (WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY | \
WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE | \
WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
static uint32_t
data_offer_choose_action(Comp_Data_Device_Offer *offer)
{
uint32_t available_actions, preferred_action = 0;
uint32_t source_actions, offer_actions;
if (wl_resource_get_version(offer->res) >=
WL_DATA_OFFER_ACTION_SINCE_VERSION)
{
offer_actions = offer->dnd_actions;
preferred_action = offer->preferred_dnd_action;
}
else
{
offer_actions = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
}
if (wl_resource_get_version(offer->source->res) >=
WL_DATA_SOURCE_ACTION_SINCE_VERSION)
source_actions = offer->source->dnd_actions;
else
source_actions = WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
available_actions = offer_actions & source_actions;
if (!available_actions)
return WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
if (offer->source->seat &&
offer->source->compositor_action & available_actions)
return offer->source->compositor_action;
/* If the dest side has a preferred DnD action, use it */
if ((preferred_action & available_actions) != 0)
return preferred_action;
/* Use the first found action, in bit order */
return 1 << (ffs(available_actions) - 1);
}
static void
data_offer_update_action(Comp_Data_Device_Offer *offer)
{
uint32_t action;
if (!offer->source)
return;
action = data_offer_choose_action(offer);
if (offer->source->current_dnd_action == action)
return;
offer->source->current_dnd_action = action;
if (offer->in_ask)
return;
if (wl_resource_get_version(offer->source->res) >=
WL_DATA_SOURCE_ACTION_SINCE_VERSION)
wl_data_source_send_action(offer->source->res, action);
if (wl_resource_get_version(offer->res) >=
WL_DATA_OFFER_ACTION_SINCE_VERSION)
wl_data_offer_send_action(offer->res, action);
}
static void
data_device_offer_set_actions(struct wl_client *client,
struct wl_resource *resource,
uint32_t dnd_actions, uint32_t preferred_action)
{
Comp_Data_Device_Offer *offer = wl_resource_get_user_data(resource);
if (dnd_actions & ~ALL_ACTIONS)
{
wl_resource_post_error(offer->res,
WL_DATA_OFFER_ERROR_INVALID_ACTION_MASK,
"invalid action mask %x", dnd_actions);
return;
}
if (preferred_action &&
(!(preferred_action & dnd_actions) ||
__builtin_popcount(preferred_action) > 1))
{
wl_resource_post_error(offer->res,
WL_DATA_OFFER_ERROR_INVALID_ACTION,
"invalid action %x", preferred_action);
return;
}
offer->dnd_actions = dnd_actions;
offer->preferred_dnd_action = preferred_action;
data_offer_update_action(offer);
}
#ifdef HAVE_ECORE_X
static Ecore_X_Atom
action_convert(uint32_t action)
{
if (action == WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
return ECORE_X_ATOM_XDND_ACTION_MOVE;
if (action == WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
return ECORE_X_ATOM_XDND_ACTION_ASK;
return ECORE_X_ATOM_XDND_ACTION_COPY;
}
#endif
static void
data_device_offer_accept(struct wl_client *client, struct wl_resource *resource,
uint32_t serial, const char *mime_type)
{
Comp_Data_Device_Offer *offer = wl_resource_get_user_data(resource);
Comp_Surface *cs;
/* Protect against untimely calls from older data offers */
if (!offer->source || offer != offer->source->offer)
return;
switch (offer->type)
{
case COMP_DATA_DEVICE_OFFER_TYPE_DND:
cs = offer->source->seat->drag.enter;
if (!offer->source->seat->drag.res) return;
if ((!offer->source->seat->drag.source) &&
(wl_resource_get_client(cs->res) != wl_resource_get_client(offer->source->seat->drag.res)))
return;
#ifdef HAVE_ECORE_X
if (offer->source->x11_owner)
{
Ecore_Window win = ecore_evas_window_get(ecore_evas_ecore_evas_get(offer->source->seat->c->evas));
offer->source->accepted = mime_type != NULL;
ecore_x_client_message32_send(offer->source->x11_owner,
ECORE_X_ATOM_XDND_STATUS, ECORE_X_EVENT_MASK_NONE,
win, 2 | !!mime_type, 0, 0,
(!!mime_type) * action_convert(offer->source->current_dnd_action));
return;
}
#endif
break;
case COMP_DATA_DEVICE_OFFER_TYPE_CLIPBOARD:
break;
default: return;
}
if (offer->source->seat->client_offer)
ecore_wl2_offer_accept(offer->source->seat->client_offer, mime_type);
else
wl_data_source_send_target(offer->source->res, mime_type);
offer->source->accepted = mime_type != NULL;
}
static void
data_device_offer_receive(struct wl_client *client, struct wl_resource *resource,
const char *mime_type, int32_t fd)
{
Comp_Data_Device_Offer *offer = wl_resource_get_user_data(resource);
if (offer->source && offer == offer->source->offer)
{
if (offer->proxy)
{
Ecore_Wl2_Offer *off;
#ifdef HAVE_ECORE_X
if (offer->source->x11_owner)
{
x11_send_send(offer->source, mime_type, fd, offer->type);
return;
}
#endif
if (offer->type == COMP_DATA_DEVICE_OFFER_TYPE_CLIPBOARD)
off = ecore_wl2_dnd_selection_get(offer->source->seat->seat);
else
{
off = offer->source->seat->client_offer;
offer->source->seat->client_offer = NULL;
}
ecore_wl2_offer_proxy_receive(off, mime_type, fd);
offer->proxy_offer = off;
}
else
wl_data_source_send_send(offer->source->res, mime_type, fd);
}
close(fd);
}
static void
data_source_notify_finish(Comp_Data_Device_Source *source)
{
if (!source->actions_set)
return;
if (source->proxy && (!source->x11_owner))
ecore_wl2_offer_finish(source->offer->proxy_offer);
if (source->offer && source->offer->in_ask &&
wl_resource_get_version(source->res) >=
WL_DATA_SOURCE_ACTION_SINCE_VERSION)
{
wl_data_source_send_action(source->res,
source->current_dnd_action);
}
if (wl_resource_get_version(source->res) >=
WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION)
{
wl_data_source_send_dnd_finished(source->res);
}
source->offer = NULL;
}
static void
data_device_offer_finish(struct wl_client *client, struct wl_resource *resource)
{
Comp_Data_Device_Offer *offer = wl_resource_get_user_data(resource);
if (!offer->source || offer->source->offer != offer)
return;
/* Disallow finish while we have a grab driving drag-and-drop, or
* if the negotiation is not at the right stage
*/
if (((!offer->proxy) && offer->source->seat) ||
!offer->source->accepted)
{
wl_resource_post_error(offer->res,
WL_DATA_OFFER_ERROR_INVALID_FINISH,
"premature finish request");
return;
}
switch (offer->source->current_dnd_action)
{
case WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE:
case WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK:
wl_resource_post_error(offer->res,
WL_DATA_OFFER_ERROR_INVALID_OFFER,
"offer finished with an invalid action");
return;
default:
break;
}
data_source_notify_finish(offer->source);
}
static void
data_device_offer_impl_destroy(struct wl_resource *resource)
{
Comp_Data_Device_Offer *offer = wl_resource_get_user_data(resource);
if (!offer->source)
goto out;
if (offer->source->offer != offer)
goto out;
if (offer->type == COMP_DATA_DEVICE_OFFER_TYPE_DND)
{
/* If the drag destination has version < 3, wl_data_offer.finish
* won't be called, so do this here as a safety net, because
* we still want the version >=3 drag source to be happy.
*/
if (wl_resource_get_version(offer->res) <
WL_DATA_OFFER_ACTION_SINCE_VERSION)
{
data_source_notify_finish(offer->source);
}
else if (offer->source->res &&
wl_resource_get_version(offer->source->res) >=
WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION)
{
wl_data_source_send_cancelled(offer->source->res);
}
}
offer->source->offer = NULL;
if (offer->proxy_offer && offer->proxy)
ecore_wl2_offer_proxy_receive_end(offer->proxy_offer);
out:
free(offer);
}
static void
drag_grab_button(Comp_Seat *s,
uint32_t time, uint32_t button, uint32_t state_w)
{
Comp_Data_Device_Source *data_source = s->drag.source;
enum wl_pointer_button_state state = state_w;
struct wl_resource *res;
if (data_source &&
s->drag.id == button &&
state == WL_POINTER_BUTTON_STATE_RELEASED)
{
if ((s->drag.enter || (s->drag.x11_owner == ecore_evas_window_get(ecore_evas_ecore_evas_get(s->c->evas)))) &&
data_source->accepted &&
data_source->current_dnd_action)
{
if (s->drag.enter)
{
res = data_device_find(s, s->drag.enter->res);
if (!res) return;
wl_data_device_send_drop(res);
}
if (wl_resource_get_version(data_source->res) >=
WL_DATA_SOURCE_DND_DROP_PERFORMED_SINCE_VERSION)
wl_data_source_send_dnd_drop_performed(data_source->res);
if (data_source->offer)
data_source->offer->in_ask =
data_source->current_dnd_action ==
WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
if (!data_source->proxy)
data_source->seat = NULL;
}
else if (wl_resource_get_version(data_source->res) >=
WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION)
{
wl_data_source_send_cancelled(data_source->res);
}
seat_drag_end(s);
if (!data_source->x11_owner)
s->drag.source = NULL;
#ifdef HAVE_ECORE_X
if (ecore_x_display_get())
ecore_x_pointer_ungrab();
#endif
}
}
#ifdef HAVE_ECORE_X
static xkb_mod_index_t x11_kbd_shift_mod;
static xkb_mod_index_t x11_kbd_caps_mod;
static xkb_mod_index_t x11_kbd_ctrl_mod;
static xkb_mod_index_t x11_kbd_alt_mod;
static xkb_mod_index_t x11_kbd_mod2_mod;
static xkb_mod_index_t x11_kbd_mod3_mod;
static xkb_mod_index_t x11_kbd_super_mod;
static xkb_mod_index_t x11_kbd_mod5_mod;
static void
keymap_mods_init(struct xkb_keymap *keymap)
{
x11_kbd_shift_mod = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
x11_kbd_caps_mod = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
x11_kbd_ctrl_mod = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
x11_kbd_alt_mod = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
x11_kbd_mod2_mod = xkb_keymap_mod_get_index(keymap, "Mod2");
x11_kbd_mod3_mod = xkb_keymap_mod_get_index(keymap, "Mod3");
x11_kbd_super_mod = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_LOGO);
x11_kbd_mod5_mod = xkb_keymap_mod_get_index(keymap, "Mod5");
}
static uint32_t
get_xkb_mod_mask(uint32_t in)
{
uint32_t ret = 0;
if ((in & ECORE_X_MODIFIER_SHIFT) && x11_kbd_shift_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_shift_mod);
if ((in & ECORE_X_LOCK_CAPS) && x11_kbd_caps_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_caps_mod);
if ((in & ECORE_X_MODIFIER_CTRL) && x11_kbd_ctrl_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_ctrl_mod);
if ((in & ECORE_X_MODIFIER_ALT) && x11_kbd_alt_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_alt_mod);
if ((in & ECORE_X_LOCK_NUM) && x11_kbd_mod2_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_mod2_mod);
if ((in & ECORE_X_LOCK_SCROLL) && x11_kbd_mod3_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_mod3_mod);
if ((in & ECORE_X_MODIFIER_WIN) && x11_kbd_super_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_super_mod);
if ((in & ECORE_X_MODIFIER_ALTGR) && x11_kbd_mod5_mod != XKB_MOD_INVALID)
ret |= (1 << x11_kbd_mod5_mod);
return ret;
}
#endif
Reference in New Issue View Git Blame Copy Permalink