}
static void
+_e_mod_comp_win_prop_check(E_Comp_Win *cw)
+{
+ Ecore_X_Window win;
+ Ecore_X_Sync_Counter counter;
+
+ E_CHECK(cw);
+ win = e_mod_comp_util_client_xid_get(cw);
+
+ // ECORE_X_ATOM_E_COMP_SYNC_COUNTER
+ counter = ecore_x_e_comp_sync_counter_get(win);
+ if (cw->counter != counter)
+ {
+ if (cw->counter)
+ {
+ ecore_x_e_comp_sync_cancel_send(win);
+ ecore_x_sync_counter_inc(cw->counter, 1);
+ cw->sync_info.val++;
+ }
+ cw->counter = counter;
+ if (cw->counter)
+ {
+ ecore_x_sync_counter_inc(cw->counter, 1);
+ ecore_x_e_comp_sync_begin_send(win);
+ cw->sync_info.val = 1;
+ }
+ }
+}
+
+static void
_e_mod_comp_win_show(E_Comp_Win *cw)
{
Ecore_X_Window win;
return ECORE_CALLBACK_PASS_ON;
}
+/* Compositor must check the client window's property that want to be shown.
+ * TODO:Compositor will check the property of ECORE_X_ATOM_E_COMP_SYNC_COUNTER for now,
+ * but the other properties may also need to check later.
+ */
+static Eina_Bool
+_e_mod_comp_show_request(void *data __UNUSED__,
+ int type __UNUSED__,
+ void *event)
+{
+ Ecore_X_Event_Window_Show_Request *ev = event;
+ E_Comp_Win *cw = _e_mod_comp_win_find(ev->win);
+ if (!cw) return ECORE_CALLBACK_PASS_ON;
+ ELBF(ELBT_COMP, 0, e_mod_comp_util_client_xid_get(cw),
+ "%15.15s|w:0x%08x|bd:%d cw:%p", "X_SHOW_REQUEST",
+ ev->win, _e_mod_comp_win_is_border(cw), cw);
+ _e_mod_comp_win_prop_check(cw);
+ return ECORE_CALLBACK_PASS_ON;
+}
+
static Eina_Bool
_e_mod_comp_show(void *data __UNUSED__,
int type __UNUSED__,
if ((cw->w == ev->border->w) && (cw->h == ev->border->h))
return ECORE_CALLBACK_PASS_ON;
_e_mod_comp_win_configure
- (cw, cw->x, cw->y,
+ (cw, ev->border->x, ev->border->y,
ev->border->w, ev->border->h, cw->border);
return ECORE_CALLBACK_PASS_ON;
}
return ECORE_CALLBACK_PASS_ON;
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
static Eina_Bool
_e_mod_comp_zone_rot_begin(void *data __UNUSED__,
int type __UNUSED__,
}
return ECORE_CALLBACK_PASS_ON;
}
+#endif
//////////////////////////////////////////////////////////////////////////
handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CREATE, _e_mod_comp_create, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DESTROY, _e_mod_comp_destroy, NULL));
+ handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW_REQUEST, _e_mod_comp_show_request, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW, _e_mod_comp_show, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_HIDE, _e_mod_comp_hide, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(ECORE_X_EVENT_WINDOW_REPARENT, _e_mod_comp_reparent, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_MOVE_RESIZE, _e_mod_comp_zone_move_resize, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_ADD, _e_mod_comp_zone_add, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_DEL, _e_mod_comp_zone_del, NULL));
+#ifdef _F_ZONE_WINDOW_ROTATION_
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_ROTATION_CHANGE_BEGIN, _e_mod_comp_zone_rot_begin, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_ROTATION_CHANGE_CANCEL, _e_mod_comp_zone_rot_cancel, NULL));
handlers = eina_list_append(handlers, ecore_event_handler_add(E_EVENT_ZONE_ROTATION_CHANGE_END, _e_mod_comp_zone_rot_end, NULL));
+#endif
res = e_mod_comp_atoms_init();
E_CHECK_RETURN(res, 0);
}
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
canvas->zr = e_mod_comp_effect_zone_rotation_new(canvas);
E_CHECK_GOTO(canvas->zr, error_cleanup);
+#endif
c->canvases = eina_list_append(c->canvases, canvas);
return canvas;
error_cleanup:
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (canvas->zr)
e_mod_comp_effect_zone_rotation_free(canvas->zr);
+#endif
EINA_LIST_FREE(canvas->layers, ly)
{
evas_object_del(canvas->bg_img);
canvas->bg_img = NULL;
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (canvas->zr)
{
e_mod_comp_effect_zone_rotation_free(canvas->zr);
canvas->zr = NULL;
}
+#endif
if (canvas->ov)
{
e_mod_comp_hw_ov_win_free(canvas->ov);
Evas_Object *bg_img;
Eina_Bool use_bg_img : 1;
E_Comp_HW_Ov_Win *ov;
+#ifdef _F_ZONE_WINDOW_ROTATION_
E_Comp_Effect_Zone_Rotation *zr;
+#endif
};
EINTERN E_Comp_Canvas *e_mod_comp_canvas_add(E_Comp *c, E_Zone *zone);
{
if (cw->c->keyboard_effect)
{
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (e_mod_comp_effect_win_angle_get(_cw))
_MAKE_EMISSION("e,state,visible,off,angle,%d", _cw->angle);
else
+#endif
_MAKE_EMISSION("e,state,visible,off,angle,0");
}
else
{
_effect_below_wins_set(cw);
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (e_mod_comp_effect_win_angle_get(cw))
_MAKE_EMISSION("e,state,window,angle,%d", cw->angle);
else
+#endif
_MAKE_EMISSION("e,state,window,angle,0");
_effect_win_set(cw, emission);
{
_effect_below_wins_set(cw);
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (e_mod_comp_effect_win_angle_get(cw))
_MAKE_EMISSION("e,state,visible,off,angle,%d", cw->angle);
else
+#endif
_MAKE_EMISSION("e,state,visible,off,angle,0");
_effect_win_set(cw, emission);
#include "e_mod_comp_effect_win_rotation.h"
#include <Elementary.h>
+#ifdef _F_ZONE_WINDOW_ROTATION_
typedef struct _E_Comp_Zone_Rotation_Effect_Begin E_Comp_Zone_Rotation_Effect_Begin;
typedef struct _E_Comp_Zone_Rotation_Effect_End E_Comp_Zone_Rotation_Effect_End;
evas_object_map_enable_set(ctx->o, EINA_TRUE);
evas_map_free(m);
}
+#endif
#ifndef E_MOD_COMP_EFFECT_WIN_ROTATION_H
#define E_MOD_COMP_EFFECT_WIN_ROTATION_H
+#ifdef _F_ZONE_WINDOW_ROTATION_
/* window rotation effect and handler functions */
EINTERN Eina_Bool e_mod_comp_effect_win_angle_get(E_Comp_Win *cw);
EINTERN Eina_Bool e_mod_comp_effect_zone_rotation_end(E_Comp_Effect_Zone_Rotation *zr);
EINTERN Eina_Bool e_mod_comp_effect_zone_rotation_cancel(E_Comp_Effect_Zone_Rotation *zr);
EINTERN Eina_Bool e_mod_comp_effect_zone_rotation_do(E_Comp_Effect_Zone_Rotation *zr);
+#endif
#endif
#endif
typedef struct _E_Comp E_Comp;
typedef struct _E_Comp_Win E_Comp_Win;
typedef struct _E_Comp_Effect_Object E_Comp_Effect_Object;
+#ifdef _F_ZONE_WINDOW_ROTATION_
typedef struct _E_Comp_Effect_Zone_Rotation E_Comp_Effect_Zone_Rotation;
+#endif
#include "e.h"
#include "e_mod_main.h"
#include <utilX.h>
+#include <utilX_ext.h>
#include "e_mod_comp_shared_types.h"
#include "e_mod_comp_debug.h"
}
if (!eina_strbuf_length_get(buf))
- return _("Unknown");
+ {
+ eina_strbuf_free(buf);
+ return _("Unknown");
+ }
label = strdup(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
# checks for pkg-config
dnl ========================================================================
#PKG_CHECK_MODULES(ENLIGHTENMENT, [enlightenment, gestureproto, xgesture])
-PKG_CHECK_MODULES(ENLIGHTENMENT, [enlightenment, sensor, vconf, dlog])
+PKG_CHECK_MODULES(ENLIGHTENMENT, [enlightenment, vconf, dlog])
ENLIGHTENMENT_CFLAGS="${ENLIGHTENMENT_CFLAGS} "
AC_SUBST(ENLIGHTENMENT_CFLAGS)
AC_SUBST(ENLIGHTENMENT_LIBS)
e_devicemgr.zone_add_handler = ecore_event_handler_add(E_EVENT_ZONE_ADD, (Ecore_Event_Handler_Cb)_e_devicemgr_cb_zone_add, NULL);
e_devicemgr.zone_del_handler = ecore_event_handler_add(E_EVENT_ZONE_DEL, (Ecore_Event_Handler_Cb)_e_devicemgr_cb_zone_del, NULL);
+ e_devicemgr.e_msg_handler = e_msg_handler_add(_e_mod_move_e_msg_handler, NULL);
+
if (!e_devicemgr.window_property_handler) SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr][%s] Failed to add ECORE_X_EVENT_WINDOW_PROPERTY handler\n", __FUNCTION__);
if (!e_devicemgr.event_generic_handler) SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr][%s] Failed to add ECORE_X_EVENT_GENERIC handler\n", __FUNCTION__);
if (!e_devicemgr.zone_add_handler) SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr][%s] Failed to add E_EVENT_ZONE_ADD handler\n", __FUNCTION__);
if (!e_devicemgr.zone_del_handler) SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr][%s] Failed to add E_EVENT_ZONE_DEL handler\n", __FUNCTION__);
+ if (!e_devicemgr.e_msg_handler) SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr][%s] Failed to add E_MSG handler\n", __FUNCTION__);
if (e_devicemgr.scrnconf_enable)
{
ecore_event_handler_del(e_devicemgr.event_generic_handler);
ecore_event_handler_del(e_devicemgr.zone_add_handler);
ecore_event_handler_del(e_devicemgr.zone_del_handler);
+ if (e_devicemgr.e_msg_handler) e_msg_handler_del(e_devicemgr.e_msg_handler);
e_devicemgr.window_property_handler = NULL;
e_devicemgr.event_generic_handler = NULL;
e_devicemgr.zone_add_handler = NULL;
{
unsigned int val = 1;
int res, ret = 1;
+ int enable = 0;
memset(&e_devicemgr, 0, sizeof(DeviceMgr));
e_devicemgr.atomDevMgrCfg = ecore_x_atom_get(STR_ATOM_DEVICEMGR_CFG);
e_devicemgr.atomFloat = ecore_x_atom_get(XATOM_FLOAT);
e_devicemgr.atomInputTransform = ecore_x_atom_get(EVDEVMULTITOUCH_PROP_TRANSFORM);
+ e_devicemgr.atomExKeyboardEnabled = ecore_x_atom_get(E_PROP_EXTERNAL_KEYBOARD_ENABLED);
ecore_x_window_prop_card32_set(e_devicemgr.rootWin, e_devicemgr.atomTouchInput, &val, 1);
+ ecore_x_window_prop_card32_set(e_devicemgr.rootWin, e_devicemgr.atomExKeyboardEnabled, &enable, 1);
memset(&e_devicemgr.virtual_touchpad_area_info, -1, sizeof(e_devicemgr.virtual_touchpad_area_info));
memset(&e_devicemgr.virtual_multitouch_id, -1, sizeof(e_devicemgr.virtual_multitouch_id));
e_devicemgr.virtual_touchpad_pointed_window = 0;
}
e_mod_scrnconf_container_bg_canvas_visible_set(EINA_FALSE);
+#ifdef _F_DEVICE_ROTATION_
if(EINA_FALSE == e_mod_sf_rotation_init())
{
SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr] Failed to init rotation!\n");
}
+#endif
out:
return ret;
static void
_e_devicemgr_fini(void)
{
+#ifdef _F_DEVICE_ROTATION_
if(EINA_FALSE == e_mod_sf_rotation_deinit())
{
SLOG(LOG_DEBUG, "DEVICEMGR", "[e_devicemgr] Failed to deinit rotation!\n");
}
+#endif
e_mod_devicemgr_config_shutdown();
}
return 1;
}
+static void
+_e_mod_move_e_msg_handler(void *data, const char *name, const char *info, int val, E_Object *obj, void *msgdata)
+{
+ Eina_List* l;
+ DeviceMgr_Device_Info *ldata;
+ unsigned int ret_val = 1;
+
+ if (!strncmp(name, "e.move.quickpanel", sizeof("e.move.quickpanel")))
+ {
+ if ((!strncmp(info, "start", sizeof("start"))))
+ {
+ // quickpanel state on
+ ret_val = 0;
+ ecore_x_window_prop_card32_set(e_devicemgr.rootWin, e_devicemgr.atomExKeyboardEnabled, &ret_val, 1);
+ EINA_LIST_FOREACH(e_devicemgr.device_list, l ,ldata)
+ {
+ if(ldata->type == E_DEVICEMGR_KEYBOARD)
+ {
+ if(_e_devicemgr_detach_slave(ldata->id) == EINA_FALSE)
+ {
+ SLOG(LOG_DEBUG, "DEVICEMGR", "[DeviceMgr] : fail to detach slave device(%d) \n", ldata->id);
+ }
+ }
+ }
+ }
+ else if ((!strncmp(info, "end", sizeof("end"))) && (val == 0))
+ {
+ // quickpanel state off
+ ret_val = 1;
+ ecore_x_window_prop_card32_set(e_devicemgr.rootWin, e_devicemgr.atomExKeyboardEnabled, &ret_val, 1);
+ EINA_LIST_FOREACH(e_devicemgr.device_list, l ,ldata)
+ {
+ if(ldata->type == E_DEVICEMGR_KEYBOARD)
+ {
+ if(_e_devicemgr_reattach_slave(ldata->id, e_devicemgr.vck_id) == EINA_FALSE)
+ {
+ SLOG(LOG_DEBUG, "DEVICEMGR", "[DeviceMgr] : fail to reattach slave device(%d) to master device(%d) \n", ldata->id, e_devicemgr.vck_id);
+ }
+ }
+ }
+ }
+ }
+}
+
static int
_e_devicemgr_xinput_init(void)
{
#define E_VIRTUAL_TOUCHPAD_NAME "Virtual Touchpad"
#define EVDEVMULTITOUCH_PROP_TRANSFORM "EvdevMultitouch Transform Matrix"
#define XATOM_FLOAT "FLOAT"
+#define E_PROP_EXTERNAL_KEYBOARD_ENABLED "External Keyboard Enabled"
+
#define DEVICEMGR_PREFIX "/usr/lib/enlightenment/modules/e17-extra-modules-devicemgr/"
Ecore_X_Atom atomFloat;
Ecore_X_Atom atomVirtualTouchpadInt;
Ecore_X_Atom atomDeviceMgrInputWindow;
+ Ecore_X_Atom atomExKeyboardEnabled;
/* scrn conf atoms */
Ecore_X_Atom atomScrnConfDispModeSet;
Ecore_Event_Handler *client_message_handler;
E_Border_Hook *border_move_end_hook;
E_Border_Hook *border_resize_end_hook;
+ E_Msg_Handler *e_msg_handler;
//variables to set XRROutputProperty
RROutput output;
static void _e_devicemgr_hook_border_resize_end(void *data, void *border);
static Eina_Bool _e_devicemgr_get_zones(void);
static E_Zone* _e_devicemgr_get_nth_zone(int index);
+static void _e_mod_move_e_msg_handler(void *data, const char *name, const char *info, int val, E_Object *obj, void *msgdata);
static void _e_devicemgr_update_input_transform_matrix(Eina_Bool reset);
static void _e_devicemgr_init_transform_matrix(void);
static void _e_devicemgr_virtual_multitouch_helper_fini(void);
static void _e_devicemgr_show_device_list(unsigned int val);
+#ifdef _F_DEVICE_ROTATION_
Eina_Bool e_mod_sf_rotation_init(void);
Eina_Bool e_mod_sf_rotation_deinit(void);
+#endif
#endif//__E_MOD_MAIN_H__
#include <X11/Xlib.h>
#include <utilX.h>
+#include <utilX_ext.h>
#define STR_ATOM_SCRNCONF_DISPMODE_SET "_SCRNCONF_DISPMODE_SET"
#define STR_ATOM_SCRNCONF_INFO "_SCRNCONF_INFO"
* Please, see the COPYING file for the original copyright owner and
* license.
*/
+#ifdef _F_DEVICE_ROTATION_
+
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
ATOM_DEVICE_ROTATION_ANGLE,
&val, 1);
}
+#endif
<request>
<domain name="_" />
</request>
+ <assign>
+ <filesystem path="/usr/bin/extndialog" label="e17" exec_label="e17" />
+ <filesystem path="/usr/bin/elogwatcher" label="_" exec_label="none" />
+ <filesystem path="/usr/bin/keygrab_status" label="_" exec_label="none" />
+ </assign>
</manifest>
--- /dev/null
+e17 system::share rwx
+e17 system::vconf_system rl
+e17 system::vconf_multimedia rl
+e17 system::vconf_network rl
+e17 system::vconf_misc rwl
+e17 system::vconf_inhouse r
+e17 system::vconf_setting rl
+e17 security-server::api-privilege-by-pid w
+e17 e17::notification rw
elm_win_title_set(win, clas);
evas_object_smart_callback_add(win, "delete,request", win_del, NULL);
elm_win_alpha_set(win, EINA_TRUE);
- elm_win_profiles_set(win, &profile, 1);
+ elm_win_profile_set(win, &profile);
pop = elm_popup_add(win);
elm_object_part_text_set(pop, "title,text", title);
}
EAPI Eina_Bool
+e_illume_border_is_app_popup(E_Border *bd)
+{
+ const char *name = NULL;
+ const char *clas = NULL;
+
+ if (!bd) return EINA_FALSE;
+
+ name = bd->client.icccm.name;
+ clas = bd->client.icccm.class;
+
+ if (clas == NULL) return EINA_FALSE;
+ if (strncmp(clas,"APP_POPUP", strlen("APP_POPUP"))!= 0) return EINA_FALSE;
+ if (name == NULL) return EINA_FALSE;
+ if (strncmp(name,"APP_POPUP", strlen("APP_POPUP"))!= 0) return EINA_FALSE;
+
+ return EINA_TRUE;
+}
+
+EAPI Eina_Bool
e_illume_border_is_fixed(E_Border *bd)
{
int min_w = 0, min_h = 0;
EAPI Eina_Bool e_illume_border_is_notification(E_Border *bd);
EAPI Eina_Bool e_illume_border_is_utility(E_Border *bd);
EAPI Eina_Bool e_illume_border_is_clipboard(E_Border *bd);
+EAPI Eina_Bool e_illume_border_is_app_popup(E_Border *bd);
EAPI void e_illume_border_min_get(E_Border *bd, int *w, int *h);
EAPI void e_illume_border_max_get(E_Border *bd, int *w, int *h);
#ifdef _F_BORDER_HOOK_PATCH_
static void _e_mod_policy_cb_hook_del_border(void *data __UNUSED__, void *data2);
#endif
+#ifdef _F_ZONE_WINDOW_ROTATION_
static void _e_mod_policy_cb_hook_rotation_list_add(void *data __UNUSED__, void *data2);
+#endif
static Eina_Bool _e_mod_policy_cb_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event);
e_border_hook_add(E_BORDER_HOOK_DEL_BORDER,
_e_mod_policy_cb_hook_del_border, NULL));
#endif
+#ifdef _F_ZONE_WINDOW_ROTATION_
_policy_hooks =
eina_list_append(_policy_hooks,
e_border_hook_add(E_BORDER_HOOK_ROTATION_LIST_ADD,
_e_mod_policy_cb_hook_rotation_list_add, NULL));
+#endif
}
static void
return ECORE_CALLBACK_RENEW;
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
static void
_e_mod_policy_cb_hook_rotation_list_add(void *data __UNUSED__, void *data2)
{
if ((_policy) && (_policy->funcs.rotation_list_add))
_policy->funcs.rotation_list_add(bd);
}
+#endif
p->funcs.illume_win_state_change_request = _policy_illume_win_state_change_request;
+#ifdef _F_ZONE_WINDOW_ROTATION_
p->funcs.rotation_list_add = _policy_border_hook_rotation_list_add;
+#endif
if (!_policy_init())
return 0;
static void _policy_border_uniconify_top_border(E_Border *bd);
/* for supporting rotation */
+#ifdef _F_ZONE_WINDOW_ROTATION_
static void _policy_border_dependent_rotation(E_Border *bd, int rotation);
static Eina_Bool _policy_dependent_rotation_check(E_Border *bd, int rotation);
+#endif
static int _prev_angle_get(Ecore_X_Window win);
e_illume_border_is_app_tray(bd) ||
e_illume_border_is_miniapp_tray(bd)))
{
- _policy_border_uniconify_below_borders_by_illume(xwin_info);
+ if (E_CONTAINS(bd->x, bd->y, bd->w, bd->h, bd->zone->x, bd->zone->y, bd->zone->w, bd->zone->h))
+ {
+ _policy_border_uniconify_below_borders_by_illume(xwin_info);
+ }
+ }
+ else
+ {
+ if (E_CONTAINS(bd->x, bd->y, bd->w, bd->h, bd->zone->x, bd->zone->y, bd->zone->w, bd->zone->h))
+ {
+ _policy_border_uniconify_below_borders_by_illume(xwin_info);
+ }
}
}
e_illume_border_is_miniapp_tray(bd) ||
(bd->client.illume.win_state.state == ECORE_X_ILLUME_WINDOW_STATE_FLOATING) ||
e_illume_border_is_syspopup(bd) ||
- e_illume_border_is_app_selector(bd))
+ e_illume_border_is_app_selector(bd) ||
+ e_illume_border_is_app_popup(bd))
dep_rot.list = eina_list_remove(dep_rot.list, bd);
if (dep_rot.refer.active_bd == bd)
}
#endif
+#ifdef _F_ZONE_WINDOW_ROTATION_
// for supporting rotation such as quickpanel
if (e_illume_border_is_quickpanel(bd) ||
e_illume_border_is_miniapp_tray(bd) ||
(bd->client.illume.win_state.state == ECORE_X_ILLUME_WINDOW_STATE_FLOATING) ||
e_illume_border_is_syspopup(bd) ||
- e_illume_border_is_app_selector(bd))
+ e_illume_border_is_app_selector(bd) ||
+ e_illume_border_is_app_popup(bd))
{
- bd->client.e.state.rot.type = E_BORDER_ROTATION_TYPE_DEPENDENT;
+ int ang = -1;
+ int next_ang = 0;
// TODO: what to do if rotation fetch is changed?
if (!eina_list_data_find(dep_rot.list, bd))
{
- int ang = -1;
- int next_ang = 0;
-
+ bd->client.e.state.rot.type = E_BORDER_ROTATION_TYPE_DEPENDENT;
if (bd->new_client)
{
ang = _prev_angle_get(bd->client.win);
bd->client.e.state.rot.curr = ang;
}
dep_rot.list = eina_list_append(dep_rot.list, bd);
+ }
- if (dep_rot.refer.active_bd) next_ang = dep_rot.refer.active_bd->client.e.state.rot.curr;
- else next_ang = dep_rot.ang;
+ // WORKAROUND: event if any property changes, E will check rotation state.
+ if (dep_rot.refer.active_bd) next_ang = dep_rot.refer.active_bd->client.e.state.rot.curr;
+ else next_ang = dep_rot.ang;
- if (next_ang != bd->client.e.state.rot.curr)
- {
- // if this border's new_client flag is set,
- // this border's show time should be posted until done of rotation.
- // will call "e_border_rotation_set" in main eval of e17
- if (_policy_dependent_rotation_check(bd, next_ang))
- bd->client.e.state.rot.changes = next_ang;
- }
+ if (next_ang != bd->client.e.state.rot.curr)
+ {
+ // if this border's new_client flag is set,
+ // this border's show time should be posted until done of rotation.
+ // will call "e_border_rotation_set" in main eval of e17
+ if (_policy_dependent_rotation_check(bd, next_ang))
+ bd->client.e.state.rot.changes = next_ang;
}
}
+#endif
/* tell E the border has changed */
bd->client.border.changed = 1;
xwin_info = _policy_xwin_info_find(bd->win);
transient_for_win = ecore_x_icccm_transient_for_get(bd->client.win);
+ if (transient_for_win)
+ {
+ bd_parent = e_border_find_by_client_window(transient_for_win);
+ }
+
+ transient_each_other = _check_parent_in_transient_for_tree(bd, bd_parent);
+ if (transient_each_other)
+ {
+ ELBF(ELBT_ILLUME, 0, bd->client.win, "TRANSEINT_FOR each other.. transient_for:0x%07x. IGNORE...", transient_for_win);
+ bd->client.icccm.transient_for = transient_for_win;
+ goto transient_fetch_done;
+ }
+
if (bd->client.icccm.transient_for == transient_for_win)
{
if (!bd->parent)
}
bd->client.icccm.transient_for = transient_for_win;
- if (bd->client.icccm.transient_for)
- {
- bd_parent = e_border_find_by_client_window(bd->client.icccm.transient_for);
- }
/* If we already have a parent, remove it */
if (bd->parent)
#ifdef _F_DEICONIFY_APPROVE_
if (bd_parent == bd->parent) change_parent = EINA_FALSE;
#endif
- bd->parent->transients = eina_list_remove(bd->parent->transients, bd);
- if (bd->parent->modal == bd) bd->parent->modal = NULL;
+ if (!e_object_is_del(E_OBJECT(bd->parent)))
+ {
+ bd->parent->transients = eina_list_remove(bd->parent->transients, bd);
+ if (bd->parent->modal == bd) bd->parent->modal = NULL;
+ }
bd->parent = NULL;
}
L(LT_TRANSIENT_FOR, "[ILLUME2][TRANSIENT_FOR] %s(%d)... win:0x%07x, parent:0x%07x\n", __func__, __LINE__, bd->client.win, bd->client.icccm.transient_for);
if (bd_parent)
{
- transient_each_other = _check_parent_in_transient_for_tree(bd, bd_parent);
- if (!transient_each_other)
+ L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. win:0x%07x(iconic:%d, by_wm:%d), parent:0x%07x(iconic:%d)\n", __func__, __LINE__, bd->client.win, bd->iconic, xwin_info ? xwin_info->iconify_by_wm : -100, bd_parent->client.win, bd_parent->iconic);
+ if (_e_illume_cfg->use_force_iconify)
{
- L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. win:0x%07x(iconic:%d, by_wm:%d), parent:0x%07x(iconic:%d)\n", __func__, __LINE__, bd->client.win, bd->iconic, xwin_info ? xwin_info->iconify_by_wm : -100, bd_parent->client.win, bd_parent->iconic);
- if (_e_illume_cfg->use_force_iconify)
+ if (!bd_parent->iconic)
{
- if (!bd_parent->iconic)
+ if (xwin_info && xwin_info->iconify_by_wm)
{
- if (xwin_info && xwin_info->iconify_by_wm)
+ if (bd->iconic)
{
- if (bd->iconic)
- {
- L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. FORCE UNICONIFY... win:0x%07x\n", __func__, __LINE__, bd->client.win);
- _policy_border_force_uniconify(bd);
- }
+ L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. FORCE UNICONIFY... win:0x%07x\n", __func__, __LINE__, bd->client.win);
+ _policy_border_force_uniconify(bd);
}
}
}
+ }
- if (bd_parent != bd)
- {
- bd->parent = bd_parent;
- _policy_border_transient_for_layer_set(bd, bd->parent, bd->parent->layer);
- bd_parent->transients = eina_list_append(bd_parent->transients, bd);
+ if (bd_parent != bd)
+ {
+ bd->parent = bd_parent;
+ _policy_border_transient_for_layer_set(bd, bd->parent, bd->parent->layer);
+ bd_parent->transients = eina_list_append(bd_parent->transients, bd);
- if ((e_config->modal_windows) && (bd->client.netwm.state.modal))
- bd->parent->modal = bd;
+ if ((e_config->modal_windows) && (bd->client.netwm.state.modal))
+ bd->parent->modal = bd;
- if (e_config->focus_setting == E_FOCUS_NEW_DIALOG ||
- (bd->parent->focused && (e_config->focus_setting == E_FOCUS_NEW_DIALOG_IF_OWNER_FOCUSED)))
- bd->take_focus = 1;
- }
+ if (e_config->focus_setting == E_FOCUS_NEW_DIALOG ||
+ (bd->parent->focused && (e_config->focus_setting == E_FOCUS_NEW_DIALOG_IF_OWNER_FOCUSED)))
+ bd->take_focus = 1;
}
}
if (!bd) return;
/* make sure we have a name so that we don't handle windows like E's root */
- if (!bd->client.icccm.name) return;
+// if (!bd->client.icccm.name) return;
// printf("Border Show: %s\n", bd->client.icccm.class);
return;
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (eina_list_data_find(dep_rot.list, bd) == bd)
{
int next_ang = 0;
if (bd->client.e.state.rot.curr != next_ang)
e_border_rotation_set(bd, next_ang);
}
+#endif
}
void
* but do not have a name/class associated with them. Not entirely sure
* which ones they are, but I would guess Managers, Containers, or Zones.
* At any rate, we're not interested in those types of borders */
- if ((!bd->client.icccm.name) || (!bd->client.icccm.class)) return;
+// if ((!bd->client.icccm.name) || (!bd->client.icccm.class)) return;
/* NB: If we have reached this point, then it should be a fullscreen
* border that has toggled fullscreen on/off */
_policy_border_indicator_control(indi_bd);
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
// will be check below condition as new_client in post_fetch time,
// so skip here.
if ((!bd->new_client) &&
if (next_ang != bd->client.e.state.rot.curr)
e_border_rotation_set(bd, next_ang);
}
+#endif
break;
case ECORE_X_ILLUME_WINDOW_STATE_NORMAL:
_policy_border_indicator_control(indi_bd);
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (eina_list_data_find(dep_rot.list, bd) == bd)
{
bd->client.e.state.rot.type = E_BORDER_ROTATION_TYPE_NORMAL;
dep_rot.list = eina_list_remove(dep_rot.list, bd);
}
+#endif
break;
}
bd->changes.size = 1;
}
static Eina_Bool
-_policy_check_transient_child_visible(E_Border *bd)
+_policy_check_transient_child_visible(E_Border *ancestor_bd, E_Border *bd)
{
Eina_Bool ret = EINA_FALSE;
E_Illume_XWin_Info *child_xwin_info = NULL;
Eina_List *l;
E_Border *child = NULL;
+ if (!ancestor_bd) return EINA_FALSE;
EINA_LIST_FOREACH(bd->transients, l, child)
{
child_xwin_info = _policy_xwin_info_find(child->win);
if (child_xwin_info)
{
- if (child_xwin_info->skip_iconify != EINA_TRUE)
+ if (child_xwin_info->skip_iconify == EINA_TRUE)
+ {
+ // special window especially keyboard, keyboard sub
+ if (child_xwin_info->visibility == E_ILLUME_VISIBILITY_UNOBSCURED)
+ {
+ return EINA_TRUE;
+ }
+ else
+ {
+ if (!child->iconic)
+ {
+ if (E_CONTAINS(child->x, child->y, child->w, child->h, ancestor_bd->x, ancestor_bd->y, ancestor_bd->w, ancestor_bd->h))
+ {
+ return EINA_TRUE;
+ }
+ }
+ }
+ }
+ else
{
if ((child_xwin_info->visibility == E_ILLUME_VISIBILITY_UNOBSCURED) ||
(!child->iconic))
if (!child->iconic) return EINA_TRUE;
}
- ret = _policy_check_transient_child_visible(child);
+ ret = _policy_check_transient_child_visible(ancestor_bd, child);
}
return ret;
int set_root_angle = 0;
int control_indi = 0;
E_Illume_XWin_Info *above_xwin_info = NULL;
+ Ecore_X_Window above_xwin = 0;
if (!_g_visibility_changed) return;
_g_visibility_changed = EINA_FALSE;
if ((xwin_info->viewable == 0) &&
(xwin_info->iconify_by_wm == 0)) continue;
- if (xwin_info->iconic) continue;
-
if (!xwin_info->is_drawed) continue;
// initializing variable
bd_info = xwin_info->bd_info;
if (bd_info) bd = bd_info->border;
+ // the illume's policy of iconify should be applied to window belonging mobile side.
+ // so, there is no need to calculate visibility.
+ if ((bd) && (!E_ILLUME_BORDER_IS_IN_MOBILE(bd))) continue;
+
+ if (xwin_info->iconic && (!xwin_info->iconify_by_wm))
+ {
+ if (bd) goto check_above;
+ else continue;
+ }
+
// 1. calculates window's region and decide it's visibility.
if (is_fully_obscured == EINA_FALSE)
{
is_opaque_win = EINA_FALSE;
}
}
+ else if (e_illume_border_is_app_tray(bd) ||
+ e_illume_border_is_miniapp_tray(bd))
+ {
+ alpha_opaque = EINA_TRUE;
+ }
if (bd->client.illume.win_state.state ==
ECORE_X_ILLUME_WINDOW_STATE_FLOATING)
is_opaque_win = EINA_FALSE;
}
+ if (win_rect.x != visible_rect.x ||
+ win_rect.y != visible_rect.y ||
+ win_rect.width != visible_rect.width ||
+ win_rect.height != visible_rect.height)
+ {
+ is_opaque_win = EINA_FALSE;
+ }
+
if (is_opaque_win)
{
win_region = ecore_x_xregion_new();
}
if (!bd) continue;
- if (!E_ILLUME_BORDER_IS_IN_MOBILE(bd)) continue;
// decide if it's the border that DO NOT iconify.
if (obscured_by_alpha_opaque)
// DO NOT iconify this border.
else if (bd->transients)
{
- do_not_iconify = _policy_check_transient_child_visible(bd);
+ do_not_iconify = _policy_check_transient_child_visible(bd, bd);
L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. win:0x%07x. Do_not_iconify:%d\n", __func__, __LINE__, xwin_info->bd_info->border->client.win, do_not_iconify);
}
}
}
}
+ /* check old above win */
+ else if (xwin_info->above_xwin != above_xwin)
+ {
+ if (!bd->iconic && !do_not_iconify && !xwin_info->skip_iconify)
+ {
+ L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. Iconify by illume.. win:0x%07x\n", __func__, __LINE__, xwin_info->bd_info->border->client.win);
+ _policy_border_iconify_by_illume(xwin_info);
+ }
+ }
}
}
}
}
}
+check_above:
+ xwin_info->above_xwin = above_xwin;
+
above_xwin_info = xwin_info;
+ above_xwin = bd->client.win;
}
if (control_indi)
// for supporting dependent rotation
if (dep_rot.refer.cmd_win == event->win)
- dep_rot.refer.cmd_win = NULL;
+ dep_rot.refer.cmd_win = 0;
}
// make rotation request for the dependent windows such as quickpanel
int ang = _policy_window_rotation_angle_get(bd->client.win);
if (ang == -1) ang = 0;
-
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (dep_rot.ang != ang)
_policy_border_dependent_rotation(bd, ang);
+#endif
}
}
E_Illume_XWin_Info* xwin_info = _policy_xwin_info_find(bd->win);
if (xwin_info == NULL) return;
- _policy_border_uniconify_below_borders_by_illume(xwin_info);
+ if (E_CONTAINS(bd->x, bd->y, bd->w, bd->h, bd->zone->x, bd->zone->y, bd->zone->w, bd->zone->h))
+ {
+ _policy_border_uniconify_below_borders_by_illume(xwin_info);
+ }
if (xwin_info->visibility != E_ILLUME_VISIBILITY_FULLY_OBSCURED)
{
if (!E_ILLUME_BORDER_IS_IN_MOBILE(bd)) return;
if (e_object_is_del(E_OBJECT(bd))) return;
+ if (!bd->visible) return;
+
if ((xwin_info->visibility != E_ILLUME_VISIBILITY_FULLY_OBSCURED) &&
(bd->parent && (!bd->parent->iconic)))
return;
E_OBJECT_CHECK(bd);
E_OBJECT_TYPE_CHECK(bd, E_BORDER_TYPE);
+ if (bd->client.e.state.deiconify_approve.wait_timer ||
+ bd->client.e.state.deiconify_approve.pending_job)
+ {
+ ELB(ELBT_BD, "DEICONIFY_APPROVE is already running", bd->client.win);
+ return;
+ }
+
xwin_info = _policy_xwin_info_find(bd->win);
if (!(xwin_info && xwin_info->iconify_by_wm)) return;
if (xwin_info->iconify_by_wm) return;
// 2. check if current bd's visibility is fully-obscured or not
- if (xwin_info->visibility == E_ILLUME_VISIBILITY_FULLY_OBSCURED) return;
+ if (xwin_info->visibility == E_ILLUME_VISIBILITY_FULLY_OBSCURED &&
+ bd->iconic)
+ {
+ return;
+ }
// 3-1. find bd's below window and un-iconify it
L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d)... UNICONIFY Below Windows of win:0x%07x\n", __func__, __LINE__, bd->client.win);
if (e_illume_border_is_app_tray(b)) continue;
if (e_illume_border_is_miniapp_tray(b)) continue;
+ if (!ecore_x_window_visible_get(b->client.win)) continue;
+
return b;
}
}
if (e_illume_border_is_app_tray(b)) continue;
if (e_illume_border_is_miniapp_tray(b)) continue;
+ if (!ecore_x_window_visible_get(b->client.win)) continue;
+
if (b->iconic)
{
- L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. FORCE UNICONIFY... win:0x%07x\n", __func__, __LINE__, b->client.win);
- _policy_border_force_uniconify(b);
+ E_Border *parent_bd;
+ E_Border *target_bd;
+ E_Illume_XWin_Info *parent_xwin_info;
+
+ target_bd = b;
+ parent_bd = b->parent;
+
+ while (parent_bd)
+ {
+ if (e_object_is_del(E_OBJECT(parent_bd))) break;
+
+ if (parent_bd->iconic)
+ {
+ parent_xwin_info = _policy_xwin_info_find(parent_bd->win);
+ if (!(parent_xwin_info && parent_xwin_info->iconify_by_wm))
+ {
+ break;
+ }
+
+ target_bd = parent_bd;
+ }
+ parent_bd = parent_bd->parent;
+ }
+
+ L(LT_ICONIFY, "[ILLUME2][ICONIFY] %s(%d).. FORCE UNICONIFY... target win:0x%07x (win:0x%07x)\n", __func__, __LINE__, target_bd->client.win, b->client.win);
+ _policy_border_force_uniconify(target_bd);
}
if ((b->x == b->zone->x) &&
return;
}
+#ifdef _F_ZONE_WINDOW_ROTATION_
/* for supporting rotation */
void
_policy_border_hook_rotation_list_add(E_Border *bd)
"[DEPENDENT] Couldn't or don't need to rotate it as given angle:%d", rotation);
return ret;
}
+#endif
static void
_policy_property_indicator_cmd_win_change(Ecore_X_Event_Window_Property *event)
ELBF(ELBT_ROT, 0, active_win,
"INDICATOR ACTIVE WIN CHANGED:0x%08x", active_win);
dep_rot.refer.active_bd = bd;
+#ifdef _F_ZONE_WINDOW_ROTATION_
rotation = bd->client.e.state.rot.curr;
_policy_border_dependent_rotation(bd, rotation);
+#endif
}
}
}
Eina_Bool is_drawed;
Eina_Bool viewable : 1; // map state
E_Illume_Border_Info* bd_info;
+ Ecore_X_Window above_xwin;
};
void _policy_border_add(E_Border *bd);
void _policy_illume_win_state_change_request(Ecore_X_Event_Client_Message *event);
+#ifdef _F_ZONE_WINDOW_ROTATION_
void _policy_border_hook_rotation_list_add(E_Border *bd);
#endif
+#endif
dnl ========================================================================
# checks for pkg-config
dnl ========================================================================
-PKG_CHECK_MODULES(ENLIGHTENMENT, enlightenment)
+PKG_CHECK_MODULES(ENLIGHTENMENT, [enlightenment,dlog])
ENLIGHTENMENT_CFLAGS="${ENLIGHTENMENT_CFLAGS} -D_GNU_SOURCE "
AC_SUBST(ENLIGHTENMENT_CFLAGS)
AC_SUBST(ENLIGHTENMENT_LIBS)
static void
_e_mod_move_bd_show_intern(E_Move_Border *mb)
{
+ E_Border *bd = NULL;
+ E_Zone *zone = NULL;
+
E_CHECK(mb);
+ bd = mb->bd;
+ E_CHECK(bd);
+ zone = bd->zone;
+ E_CHECK(zone);
if (mb->visible) return;
mb->visible = 1;
e_mod_move_indicator_e_border_move(mb, -10000, -10000);
// If Quickpanel is shown, then move out of screen.
if (TYPE_QUICKPANEL_CHECK(mb))
- e_mod_move_quickpanel_e_border_move(mb, -10000, -10000);
+ {
+ e_mod_move_quickpanel_e_border_move(mb, -10000, -10000);
+ ecore_x_e_illume_quickpanel_state_set(zone->black_win, ECORE_X_ILLUME_QUICKPANEL_STATE_OFF);
+ }
}
static void
E_Move *m = e_mod_move_util_get();
E_CHECK_RETURN(m, EINA_FALSE);
E_CHECK_RETURN(mb, EINA_FALSE);
- E_CHECK_RETURN(TYPE_APPTRAY_CHECK(mb), EINA_FALSE);
if ((!m->elm_indicator_mode) && e_mod_move_indicator_click_get()) // if indicator process event, do event clear
e_mod_move_indicator_event_clear();
if ((m->elm_indicator_mode)
Eina_Bool state;
Eina_Bool comp_obj_visible = EINA_FALSE;
E_Zone *zone;
+ Eina_Bool scrolling_state = EINA_FALSE;
int cx, cy, cw, ch;
int open, angles[2];
int ax = 0; // animation x
comp_obj_visible = e_mod_move_util_compositor_object_visible_get(qp_mb);
- zone = qp_mb->bd->zone;
- if (REGION_INSIDE_ZONE(qp_mb, zone)) state = EINA_TRUE;
- else state = EINA_FALSE;
-
- if ((!m->elm_indicator_mode)
- && e_mod_move_indicator_click_get())
+ if (((!m->elm_indicator_mode) && e_mod_move_indicator_click_get())
+ || ((m->elm_indicator_mode)
+ && e_mod_move_indicator_widget_click_get(e_mod_move_indicator_widget_get()))
+ || (e_mod_move_quickpanel_click_get()))
{
- L(LT_EVENT_X,
- "[MOVE] ev:%15.15s [MOVE_MODULE] _E_ILLUME_QUICKPANEL_STATE error. w:0x%07x(state:%d) request:%d, Indicator Is Scrolling\n",
- "X_CLIENT_MESSAGE", win, state, open);
- return EINA_FALSE;
+ scrolling_state = EINA_TRUE;
}
- if ((m->elm_indicator_mode)
- && e_mod_move_indicator_widget_click_get(e_mod_move_indicator_widget_get()))
- {
- L(LT_EVENT_X,
- "[MOVE] ev:%15.15s [MOVE_MODULE] _E_ILLUME_QUICKPANEL_STATE error. w:0x%07x(state:%d) request:%d, Indicator Widget Is Scrolling\n",
- "X_CLIENT_MESSAGE", win, state, open);
- return EINA_FALSE;
- }
-
- if (e_mod_move_quickpanel_click_get())
- {
- L(LT_EVENT_X,
- "[MOVE] ev:%15.15s [MOVE_MODULE] _E_ILLUME_QUICKPANEL_STATE error. w:0x%07x(state:%d) request:%d, Quickpanel Is Scrolling\n",
- "X_CLIENT_MESSAGE", win, state, open);
- return EINA_FALSE;
- }
+ zone = qp_mb->bd->zone;
+ if (REGION_INSIDE_ZONE(qp_mb, zone)) state = EINA_TRUE;
+ else state = EINA_FALSE;
- if ((open) && (!state) && (comp_obj_visible)) // Quickpanel Open
+ if ((open) && ((!state) || scrolling_state) && (comp_obj_visible)) // Quickpanel Open
{
switch (angles[0])
{
e_mod_move_quickpanel_objs_add(qp_mb);
// send quickpanel to "move start message".
- e_mod_move_quickpanel_anim_state_send(qp_mb, EINA_TRUE);
+ if (!scrolling_state) e_mod_move_quickpanel_anim_state_send(qp_mb, EINA_TRUE);
e_mod_move_quickpanel_e_border_move(qp_mb, mx, my);
- e_mod_move_quickpanel_objs_animation_start_position_set(qp_mb,
- angles[0],
- EINA_FALSE);
+ if (!scrolling_state)
+ e_mod_move_quickpanel_objs_animation_start_position_set(qp_mb,
+ angles[0],
+ EINA_FALSE);
e_mod_move_quickpanel_objs_animation_move(qp_mb, ax, ay);
}
- else if ((!open) && (state))// Quickpanel Close
+ else if ((!open) && (state || scrolling_state))// Quickpanel Close
{
switch (angles[0])
{
e_mod_move_quickpanel_objs_add(qp_mb);
// send quickpanel to "move start message".
- e_mod_move_quickpanel_anim_state_send(qp_mb, EINA_TRUE);
+ if (!scrolling_state) e_mod_move_quickpanel_anim_state_send(qp_mb, EINA_TRUE);
e_mod_move_quickpanel_e_border_move(qp_mb, mx, my);
- e_mod_move_quickpanel_objs_animation_start_position_set(qp_mb,
- angles[0],
- EINA_TRUE);
+
+ if (!scrolling_state)
+ e_mod_move_quickpanel_objs_animation_start_position_set(qp_mb,
+ angles[0],
+ EINA_TRUE);
e_mod_move_quickpanel_objs_animation_move(qp_mb, ax, ay);
}
else
EINTERN Ecore_X_Atom ATOM_MV_INDICATOR_GEOMETRY = 0;
EINTERN Ecore_X_Atom ATOM_INDICATOR_CMD_WIN = 0;
EINTERN Ecore_X_Atom ATOM_ACTIVE_INDICATOR_WIN = 0;
+EINTERN Ecore_X_Atom ATOM_INDICATOR_FLICK_DONE = 0;
/* local subsystem globals */
static Eina_Hash *atoms_hash = NULL;
"_E_MOVE_PANEL_SCROLLABLE_STATE",
"_E_MOVE_INDICATOR_GEOMETRY",
"_E_INDICATOR_CMD_WIN",
- "_E_ACTIVE_INDICATOR_WIN"
+ "_E_ACTIVE_INDICATOR_WIN",
+ "_E_INDICATOR_FLICK_DONE"
};
static const char *external_atom_names[] = {
ATOM_MV_INDICATOR_GEOMETRY = atoms[i++];
ATOM_INDICATOR_CMD_WIN = atoms[i++];
ATOM_ACTIVE_INDICATOR_WIN = atoms[i++];
+ ATOM_INDICATOR_FLICK_DONE = atoms[i++];
for (i = 0; i < n; i++)
{
extern EINTERN Ecore_X_Atom ATOM_MV_INDICATOR_GEOMETRY;
extern EINTERN Ecore_X_Atom ATOM_INDICATOR_CMD_WIN;
extern EINTERN Ecore_X_Atom ATOM_ACTIVE_INDICATOR_WIN;
+extern EINTERN Ecore_X_Atom ATOM_INDICATOR_FLICK_DONE;
EINTERN int e_mod_move_atoms_init(void);
EINTERN int e_mod_move_atoms_shutdown(void);
#include "e_mod_move_shared_types.h"
#include "e_mod_move_debug.h"
-#include <pixman.h>
-
/* local subsystem functions */
E_MOVE_BORDER_CLASS_TYPE_MINI_APPTRAY,
E_MOVE_BORDER_CLASS_TYPE_SETUP_WIZARD,
E_MOVE_BORDER_CLASS_TYPE_APP_SELECTOR,
+ E_MOVE_BORDER_CLASS_TYPE_APP_POPUP,
E_MOVE_BORDER_CLASS_TYPE_PWLOCK,
E_MOVE_BORDER_CLASS_TYPE_BACKGROUND,
E_MOVE_BORDER_CLASS_TYPE_ISF,
E_MOVE_BORDER_NAME_TYPE_MINI_APPTRAY,
E_MOVE_BORDER_NAME_TYPE_SETUP_WIZARD,
E_MOVE_BORDER_NAME_TYPE_APP_SELECTOR,
+ E_MOVE_BORDER_NAME_TYPE_APP_POPUP,
E_MOVE_BORDER_NAME_TYPE_PWLOCK,
E_MOVE_BORDER_NAME_TYPE_BACKGROUND,
E_MOVE_BORDER_NAME_TYPE_ISF_KEYBOARD,
"MINIAPP_TRAY",
"SETUP_WIZARD",
"APP_SELECTOR",
+ "APP_POPUP",
//"PW_LOCK",
"pwlock",
"BACKGROUND",
"MINIAPP_TRAY",
"SETUP_WIZARD",
"APP_SELECTOR",
+ "APP_POPUP",
//"PW_LOCK",
"pwlock",
"BACKGROUND",
"E_MOVE_BORDER_TYPE_APPTRAY",
"E_MOVE_BORDER_TYPE_MINI_APPTRAY",
"E_MOVE_BORDER_TYPE_SETUP_WIZARD",
+ "E_MOVE_BORDER_TYPE_APP_SELECTOR",
+ "E_MOVE_BORDER_TYPE_APP_POPUP",
"E_MOVE_BORDER_TYPE_PWLOCK",
"E_MOVE_BORDER_TYPE_BACKGROUND",
"E_MOVE_BORDER_TYPE_ISF_KEYBOARD",
E_MOVE_BORDER_CLASS_TYPE_MINI_APPTRAY,
E_MOVE_BORDER_CLASS_TYPE_SETUP_WIZARD,
E_MOVE_BORDER_CLASS_TYPE_APP_SELECTOR,
+ E_MOVE_BORDER_CLASS_TYPE_APP_POPUP,
E_MOVE_BORDER_CLASS_TYPE_PWLOCK,
E_MOVE_BORDER_CLASS_TYPE_BACKGROUND,
E_MOVE_BORDER_CLASS_TYPE_ISF
E_MOVE_BORDER_NAME_TYPE_MINI_APPTRAY,
E_MOVE_BORDER_NAME_TYPE_SETUP_WIZARD,
E_MOVE_BORDER_NAME_TYPE_APP_SELECTOR,
+ E_MOVE_BORDER_NAME_TYPE_APP_POPUP,
E_MOVE_BORDER_NAME_TYPE_PWLOCK,
E_MOVE_BORDER_NAME_TYPE_BACKGROUND,
E_MOVE_BORDER_NAME_TYPE_ISF_KEYBOARD,
if (ntype == E_MOVE_BORDER_NAME_TYPE_APP_SELECTOR)
res = E_MOVE_BORDER_TYPE_APP_SELECTOR;
break;
+ case E_MOVE_BORDER_CLASS_TYPE_APP_POPUP:
+ if (ntype == E_MOVE_BORDER_NAME_TYPE_APP_POPUP)
+ res = E_MOVE_BORDER_TYPE_APP_POPUP;
+ break;
case E_MOVE_BORDER_CLASS_TYPE_PWLOCK:
if (ntype == E_MOVE_BORDER_NAME_TYPE_PWLOCK)
res = E_MOVE_BORDER_TYPE_PWLOCK;
#define TYPE_APP_SELECTOR_CHECK(a) \
((a)->type == E_MOVE_BORDER_TYPE_APP_SELECTOR)
+#define TYPE_APP_POPUP_CHECK(a) \
+ ((a)->type == E_MOVE_BORDER_TYPE_APP_POPUP)
+
typedef enum _E_Move_Border_Type
{
E_MOVE_BORDER_TYPE_UNKNOWN = 0,
E_MOVE_BORDER_TYPE_MINI_APPTRAY,
E_MOVE_BORDER_TYPE_SETUP_WIZARD,
E_MOVE_BORDER_TYPE_APP_SELECTOR,
+ E_MOVE_BORDER_TYPE_APP_POPUP,
E_MOVE_BORDER_TYPE_PWLOCK,
E_MOVE_BORDER_TYPE_BACKGROUND,
E_MOVE_BORDER_TYPE_ISF_KEYBOARD,
#include "e_mod_move_shared_types.h"
#include "e_mod_move_debug.h"
#include "e_mod_move.h"
+#include "e_mod_move_atoms.h"
/* local subsystem functions */
static Eina_Bool _e_mod_move_indicator_widget_apptray_move_set(E_Move_Indicator_Widget *indi_widget, Eina_Bool state);
static Eina_Bool _e_mod_move_indicator_widget_cb_motion_end(void *data, void *event_info);
static void _e_mod_move_indicator_widget_obj_event_setup(E_Move_Indicator_Widget *indicator_widget, E_Move_Widget_Object *mwo);
static Eina_Bool _e_mod_move_indicator_widget_scrollable_object_movable_check(E_Move_Indicator_Widget *indi_widget, E_Move_Border *mb, Evas_Point pos);
-static Eina_Bool _e_mod_move_indicator_widget_target_window_find_by_pointer(Ecore_X_Window *win, int x, int y);
+static Eina_Bool _e_mod_move_indicator_widget_target_window_find_by_pointer(Ecore_X_Window *win, Ecore_X_Window *pointed_win, int x, int y);
+static Eina_Bool _e_mod_move_indicator_widget_focus_target_window_find_by_pointer(Ecore_X_Window *win, int x, int y);
static Ecore_X_Window _e_mod_move_indicator_widget_event_win_find(void *event_info);
static Eina_Bool _e_mod_move_indicator_widget_target_window_policy_check(E_Move_Border *mb);
static Eina_Bool _e_mod_move_indicator_widget_event_send_policy_check(E_Move_Indicator_Widget *indi_widget, Evas_Point pos);
// It's posible that WM doesn't send rotation change request yet.
// In this case the value of wait_for_done is zero,
// it means quickpanel isn't rotating for now, but going to be rotated.
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (qp_mb->bd)
if (qp_mb->bd->client.e.state.rot.wait_for_done) return EINA_FALSE;
+#endif
if (e_mod_move_quickpanel_objs_animation_state_get(qp_mb)) return EINA_FALSE;
E_Move_Border *mb = NULL;
E_Move_Border *ev_mb = NULL;
+ E_Move_Border *focus_mb = NULL;
E_Move_Border *qp_mb = NULL;
E_Move_Border *at_mb = NULL;
E_Move_Event_Motion_Info *info;
Eina_List *l;
E_Move_Scroll_Region_Indicator scroll_region = E_MOVE_SCROLL_REGION_NONE;
Ecore_X_Window ev_win = 0;
+ Ecore_X_Window focus_win = 0;
info = (E_Move_Event_Motion_Info *)event_info;
m = e_mod_move_util_get();
E_CHECK_RETURN(indi_widget, EINA_FALSE);
+ E_CHECK_RETURN(info, EINA_FALSE);
+ E_CHECK_RETURN(m, EINA_FALSE);
+ mb = e_mod_move_border_client_find(indi_widget->win);
+ E_CHECK_RETURN(mb, EINA_FALSE);
// clicked window indicator policy check
EINA_LIST_FOREACH(indi_widget->objs, l, mwo)
{
if (!mwo) continue;
ev_win = e_mod_move_event_win_get(mwo->event);
+ if (!ev_win)
+ {
+ _e_mod_move_indicator_widget_target_window_find_by_pointer(&ev_win, NULL,
+ info->coord.x,
+ info->coord.y);
+ }
}
ev_mb = e_mod_move_border_client_find(ev_win);
- if (ev_mb && ev_mb->bd && ev_mb->bd->layer)
- if (ev_mb->bd->layer == e_mod_move_util_layer_policy_get(E_MOVE_STATE_ABOVE_LAYER))
- e_focus_event_mouse_down(ev_mb->bd);
-
- E_CHECK_RETURN(_e_mod_move_indicator_widget_target_window_policy_check(ev_mb),
- EINA_FALSE);
-
- mb = e_mod_move_border_client_find(indi_widget->win);
-
- if (!m || !mb || !indi_widget || !info) return EINA_FALSE;
+ _e_mod_move_indicator_widget_focus_target_window_find_by_pointer(&focus_win, info->coord.x, info->coord.y);
+ focus_mb = e_mod_move_border_client_find(focus_win);
+ if (focus_mb && focus_mb->bd)
+ if ((focus_mb->bd->client.icccm.accepts_focus) || (focus_mb->bd->client.icccm.take_focus))
+ e_focus_event_mouse_down(focus_mb->bd);
mouse_down_event = info->event_info;
E_CHECK_RETURN(mouse_down_event, EINA_FALSE);
if (clicked)
return EINA_FALSE;
+ EINA_LIST_FOREACH(indi_widget->objs, l, mwo)
+ {
+ if (!mwo) continue;
+ e_mod_move_event_click_set(mwo->event, EINA_TRUE);
+ }
+
+ if (!_e_mod_move_indicator_widget_target_window_policy_check(ev_mb))
+ {
+ E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
+ e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
+
+ indi_widget->send_flick_done = EINA_TRUE;
+ indi_widget->flicked = 0;
+ indi_widget->target = ev_win;
+ return EINA_FALSE;
+ }
+
SL(LT_EVENT_OBJ,
"[MOVE] ev:%15.15s w:0x%08x INDI_WIDGET_MOTION_START (%4d,%4d)\n",
"EVAS_OBJ", mb->bd->win,
return EINA_FALSE;
}
- EINA_LIST_FOREACH(indi_widget->objs, l, mwo)
- {
- if (!mwo) continue;
- e_mod_move_event_click_set(mwo->event, EINA_TRUE);
- }
-
- E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
- e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
+ E_CHECK_GOTO(e_mod_move_flick_data_new(mb), error_cleanup);
+ e_mod_move_flick_data_init(mb, info->coord.x, info->coord.y);
scroll_region = e_mod_move_indicator_region_scroll_check(mb->angle, info->coord);
if (need_move)
e_mod_move_apptray_objs_move(at_mb, x, y);
}
+ else if (indi_widget->send_flick_done)
+ {
+ if (!indi_widget->flicked)
+ {
+ e_mod_move_flick_data_update(mb, info->coord.x, info->coord.y);
+ if (e_mod_move_flick_state_get(mb, EINA_TRUE))
+ {
+ indi_widget->flicked = 1;
+ ecore_x_client_message32_send
+ (indi_widget->target, ATOM_INDICATOR_FLICK_DONE,
+ ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
+ 1, 0, 0, 0, 0);
+ }
+ }
+ }
indi_widget->pos = info->coord; // save mouse move position
}
E_CHECK_GOTO(click, error_cleanup);
+ if(indi_widget->send_flick_done)
+ {
+ indi_widget->send_flick_done = EINA_FALSE;
+ indi_widget->flicked = 0;
+ indi_widget->target = 0;
+ }
+
qp_mv_state = _e_mod_move_indicator_widget_quickpanel_move_get(indi_widget);
at_mv_state = _e_mod_move_indicator_widget_apptray_move_get(indi_widget);
if (!qp_mv_state && !at_mv_state) goto finish;
static Eina_Bool
_e_mod_move_indicator_widget_target_window_find_by_pointer(Ecore_X_Window *win,
+ Ecore_X_Window *pointed_win,
int x,
int y)
{
m = e_mod_move_util_get();
E_CHECK_RETURN(m, EINA_FALSE);
+ if (pointed_win) *pointed_win = 0;
+
EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
{
if (!find_mb->bd) continue;
// finding pointed border
if (!E_INSIDE(x, y, find_mb->bd->x, find_mb->bd->y,
find_mb->bd->w, find_mb->bd->h))
- continue;
+ {
+ continue;
+ }
+ else
+ {
+ if (pointed_win && *pointed_win == 0)
+ *pointed_win = find_mb->bd->client.win;
+ }
// if notification , alpha, and indicator_state_none then search again below.
- if ((TYPE_NOTIFICATION_CHECK(find_mb) || TYPE_APP_SELECTOR_CHECK(find_mb))
- && (find_mb->argb)
- && (find_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
+ if (((TYPE_NOTIFICATION_CHECK(find_mb)) ||
+ (TYPE_APP_SELECTOR_CHECK(find_mb)) ||
+ (TYPE_APP_POPUP_CHECK(find_mb))) &&
+ (find_mb->argb) &&
+ (find_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
{
if (!noti_win_saved)
{
return ret;
}
+static Eina_Bool
+_e_mod_move_indicator_widget_focus_target_window_find_by_pointer(Ecore_X_Window *win,
+ int x,
+ int y)
+{
+ E_Move *m = NULL;
+ E_Move_Border *find_mb = NULL;
+ Eina_Bool found = EINA_FALSE;
+ Eina_Bool ret = EINA_FALSE;
+
+ E_CHECK_RETURN(win, EINA_FALSE);
+ m = e_mod_move_util_get();
+ E_CHECK_RETURN(m, EINA_FALSE);
+
+ EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
+ {
+ if (!find_mb->bd) continue;
+
+ // finding visible border
+ if (!find_mb->visible) continue;
+
+ // finding pointed border
+ if (!E_INSIDE(x, y, find_mb->bd->x, find_mb->bd->y,
+ find_mb->bd->w, find_mb->bd->h))
+ {
+ continue;
+ }
+ else
+ {
+ found = EINA_TRUE;
+ break;
+ }
+ }
+
+ if (found)
+ {
+ *win = find_mb->bd->client.win;
+ ret = EINA_TRUE;
+ }
+
+ return ret;
+}
+
static Ecore_X_Window
_e_mod_move_indicator_widget_event_win_find(void *event_info)
{
E_Move_Event_Motion_Info *info = NULL;
- Ecore_X_Window win = 0, res_win = 0;
+ Ecore_X_Window win = 0, res_win = 0, pointed_win = 0;
info = (E_Move_Event_Motion_Info *)event_info;
E_CHECK_RETURN(info, 0);
if (_e_mod_move_indicator_widget_target_window_find_by_pointer(&win,
+ &pointed_win,
info->coord.x,
info->coord.y))
{
- res_win = win;
+ if (pointed_win == win)
+ res_win = win;
}
SL(LT_EVENT_OBJ,
- "[MOVE] ev:%15.15s INDICATOR_WIDGET_EVENT_WIN_FIND w:0x%08x (%4d,%4d)\n",
- "EVAS_OBJ", res_win, info->coord.x, info->coord.y);
+ "[MOVE] ev:%15.15s INDICATOR_WIDGET_EVENT_WIN_FIND res_w:0x%08x w:0x%08x pointed_w:0x%08x (%4d,%4d)\n",
+ "EVAS_OBJ", res_win, win, pointed_win, info->coord.x, info->coord.y);
return res_win;
}
{
target_mb = e_mod_move_border_client_find(target_win);
E_CHECK(target_mb);
- if ((TYPE_NOTIFICATION_CHECK(target_mb) || TYPE_APP_SELECTOR_CHECK(target_mb))
- && (target_mb->argb)
- && (target_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
+ if ((TYPE_NOTIFICATION_CHECK(target_mb) ||
+ TYPE_APP_SELECTOR_CHECK(target_mb) ||
+ TYPE_APP_POPUP_CHECK(target_mb)) &&
+ (target_mb->argb) &&
+ (target_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
{
EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
{
if (TYPE_QUICKPANEL_CHECK(find_mb)) continue;
// find system popup's below border
- if ((TYPE_NOTIFICATION_CHECK(find_mb) || TYPE_APP_SELECTOR_CHECK(find_mb))
- && (find_mb->argb)
- && (find_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
+ if ((TYPE_NOTIFICATION_CHECK(find_mb) ||
+ TYPE_APP_SELECTOR_CHECK(find_mb) ||
+ TYPE_APP_POPUP_CHECK(find_mb)) &&
+ (find_mb->argb) &&
+ (find_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
{
continue;
}
// OnScreen & FullScreen Window
- if (find_mb->visible
- && REGION_EQUAL_TO_ZONE(find_mb, zone) // check fullscreen
- && (zone->id == 0))// change zone->id comparing to bd's profile property (mobile)
+ if ((find_mb->visible) &&
+ (zone->id == 0) && // change zone->id comparing to bd's profile property (mobile)
+ (REGION_EQUAL_TO_ZONE(find_mb, zone))) // check fullscreen
{
active_indi_win_found = EINA_TRUE;
break;
e_mod_move_indicator_widget_del(indi_widget);
e_mod_move_indicator_widget_set(e_mod_move_indicator_widget_add(target_win));
if ((target_mb) &&
- (TYPE_NOTIFICATION_CHECK(target_mb) || TYPE_APP_SELECTOR_CHECK(target_mb)) &&
+ (TYPE_NOTIFICATION_CHECK(target_mb) ||
+ TYPE_APP_SELECTOR_CHECK(target_mb) ||
+ TYPE_APP_POPUP_CHECK(target_mb)) &&
(target_mb->argb) &&
(target_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
{
e_mod_move_indicator_widget_set(e_mod_move_indicator_widget_add(target_win));
if ((target_mb) &&
- (TYPE_NOTIFICATION_CHECK(target_mb) || TYPE_APP_SELECTOR_CHECK(target_mb)) &&
+ (TYPE_NOTIFICATION_CHECK(target_mb) ||
+ TYPE_APP_SELECTOR_CHECK(target_mb) ||
+ TYPE_APP_POPUP_CHECK(target_mb)) &&
(target_mb->argb) &&
(target_mb->indicator_state == E_MOVE_INDICATOR_STATE_NONE))
{
Ecore_X_Window win;
Eina_Bool quickpanel_move;
Eina_Bool apptray_move;
+ Eina_Bool send_flick_done;
Eina_Bool move_started;
+
Evas_Point pos; // mouse position
int input_region_id;
+
+ Ecore_X_Window target; //releate send_flick_done
+ Eina_Bool flicked; //releate send_flick_done
};
typedef struct _E_Move_Indicator_Widget E_Move_Indicator_Widget;
// It's posible that WM doesn't send rotation change request yet.
// In this case the value of wait_for_done is zero,
// it means quickpanel isn't rotating for now, but going to be rotated.
+#ifdef _F_ZONE_WINDOW_ROTATION_
if (mini_apptray_mb->bd)
if (mini_apptray_mb->bd->client.e.state.rot.wait_for_done) return EINA_FALSE;
+#endif
// check if notification window is on-screen.
EINA_INLIST_REVERSE_FOREACH(m->borders, find_mb)
}
}
- // if qp_scroll_with_clipping case, make cw / ch data for e_mod_move_util_fb_move()
if (m->qp_scroll_with_clipping)
{
switch (angle)
}
}
- e_mod_move_util_fb_move(angle, cw, ch, x, y);
-
return EINA_TRUE;
}
}
}
- e_mod_move_util_fb_move(curr_angle, cw, ch, ax, ay);
-
return EINA_TRUE;
}
_e_mod_move_quickpanel_comp_layer_obj_move_intern(mx, my);
- // if qp_scroll_with_clipping case, make cw / ch data for e_mod_move_util_fb_move()
if (m->qp_scroll_with_clipping)
{
switch (angle)
}
}
- e_mod_move_util_fb_move(angle, cw, ch, x, y);
-
return EINA_TRUE;
}
EINTERN Eina_Bool
e_mod_move_quickpanel_angle_change_post_job(E_Move_Border *mb)
{
+ E_Zone *zone = NULL;
+ E_Border *bd = NULL;
+
E_CHECK_RETURN(mb, EINA_FALSE);
E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
+ bd = mb->bd;
+ E_CHECK_RETURN(bd, EINA_FALSE);
+ zone = bd->zone;
+ E_CHECK_RETURN(zone, EINA_FALSE);
+
+ if (!e_mod_move_quickpanel_objs_animation_state_get(mb)
+ && REGION_INTERSECTS_WITH_ZONE(mb, zone))
+ e_mod_move_quickpanel_objs_animation_start_position_set(mb, mb->angle, EINA_TRUE);
if (e_mod_move_quickpanel_objs_animation_state_get(mb))
return _e_mod_move_quickpanel_animation_change_with_angle(mb);
else
return _e_mod_move_quickpanel_fb_move_change_with_angle(mb);
+
}
static Eina_Bool
{
long d[5] = {0L, 0L, 0L, 0L, 0L};
Ecore_X_Window win;
+ E_Move *m;
+ E_Zone *zone = NULL;
+ E_Border *bd = NULL;
+ int on_screen_state = 0;
+
E_CHECK_RETURN(mb, EINA_FALSE);
E_CHECK_RETURN(TYPE_QUICKPANEL_CHECK(mb), EINA_FALSE);
+ m = mb->m;
+ E_CHECK_RETURN(m, EINA_FALSE);
win = e_mod_move_util_client_xid_get(mb);
E_CHECK_RETURN(win, 0);
+ bd = mb->bd;
+ E_CHECK_RETURN(bd, EINA_FALSE);
+ zone = bd->zone;
+ E_CHECK_RETURN(zone, EINA_FALSE);
+
if (state) d[0] = 1L;
else d[0] = 0L;
+ if (REGION_INTERSECTS_WITH_ZONE(mb, zone)) on_screen_state = 1;
+
+ if (state)
+ e_msg_send("e.move.quickpanel", "start", on_screen_state, E_OBJECT(m->man), NULL, NULL, NULL);
+ else
+ e_msg_send("e.move.quickpanel", "end", on_screen_state, E_OBJECT(m->man), NULL, NULL, NULL);
+
ecore_x_client_message32_send
(win, ATOM_MV_QUICKPANEL_STATE,
ECORE_X_EVENT_MASK_WINDOW_CONFIGURE,
zone = e_util_zone_current_get(man);
E_CHECK(zone);
-
+#ifdef _F_ZONE_WINDOW_ROTATION_
e_zone_rotation_block_set(zone, "move-tizen", EINA_TRUE);
+#endif
ecore_x_window_prop_card32_set(m->man->root, ATOM_ROTATION_LOCK, &val, 1);
}
zone = e_util_zone_current_get(man);
E_CHECK(zone);
+#ifdef _F_ZONE_WINDOW_ROTATION_
e_zone_rotation_block_set(zone, "move-tizen", EINA_FALSE);
+#endif
ecore_x_window_prop_card32_set(m->man->root, ATOM_ROTATION_LOCK, &val, 1);
}
e_manager_comp_composite_mode_set(man, zone, set);
}
-EINTERN void
-e_mod_move_util_fb_move(int angle,
- int cw,
- int ch,
- int x,
- int y)
-{
- Ecore_X_Display *d = ecore_x_display_get();
- int fb_x = 0, fb_y = 0;
- E_CHECK(d);
-
- switch (angle)
- {
- case 0: fb_x = 0; fb_y = y + ch; break;
- case 90: fb_x = x + cw; fb_y = 0; break;
- case 180: fb_x = 0; fb_y = y - ch; break;
- case 270: fb_x = x - cw; fb_y = 0; break;
- default :
- break;
- }
-
- utilx_set_video_offset(d, fb_x, fb_y);
-}
-
EINTERN int
e_mod_move_util_layer_policy_get(E_Move_Layer_Policy layer)
{
EINTERN Eina_Bool e_mod_move_util_compositor_object_visible_get(E_Move_Border *mb);
EINTERN E_Move_Border *e_mod_move_util_visible_fullscreen_window_find(void);
EINTERN void e_mod_move_util_compositor_composite_mode_set(E_Move *m, Eina_Bool set);
-EINTERN void e_mod_move_util_fb_move(int angle, int cw, int ch, int x, int y);
EINTERN int e_mod_move_util_layer_policy_get(E_Move_Layer_Policy layer);
EINTERN E_Border *e_mod_move_util_border_find_by_pointer(int x, int y);
EINTERN int e_mod_move_util_root_angle_get(void);
+++ /dev/null
-* Wed Nov 28 2012 Anas Nashif <anas.nashif@intel.com> accepted/trunk/20121113.042536@ff62a74
-- Use libX11 instead of libx11
+%bcond_with x
Name: e17-extra-modules
-Summary: The E17 Extra Modules The E17 extra modules consists of modules made by SAMSUNG
-Version: 0.14.11
+Summary: The E17 Extra Modules for Tizen
+Version: 0.10.116
Release: 1
Group: System/GUI/Other
-License: BSD
+License: BSD-2-Clause
Source0: %{name}-%{version}.tar.gz
-BuildRequires: pkgconfig(enlightenment)
+BuildRequires: e17-devel
BuildRequires: pkgconfig(utilX)
BuildRequires: pkgconfig(elementary)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(xfixes)
BuildRequires: pkgconfig(xext)
BuildRequires: pkgconfig(edje)
+BuildRequires: pkgconfig(eina)
+BuildRequires: pkgconfig(ecore)
+BuildRequires: pkgconfig(ecore-x)
BuildRequires: pkgconfig(xrandr)
BuildRequires: pkgconfig(evas)
BuildRequires: pkgconfig(xi)
BuildRequires: pkgconfig(xtst)
BuildRequires: pkgconfig(pixman-1)
-BuildRequires: pkgconfig(sensor)
BuildRequires: pkgconfig(vconf)
+BuildRequires: cmake
+BuildRequires: gettext
BuildRequires: edje-tools
+
Requires: libX11
-Requires: sensor
Requires: vconf
%description
%prep
%setup -q
-
%build
+%define DEF_SUBDIRS illume2-tizen comp-tizen keyrouter wmready accessibility move-tizen devicemgr extndialog screen-reader
-%define DEF_SUBDIRS comp-tizen illume2-tizen keyrouter wmready accessibility move-tizen devicemgr extndialog screen-reader devmode-tizen
-
-export CFLAGS+=" -Wall -g -fPIC -rdynamic"
+export GC_SECTIONS_FLAGS="-fdata-sections -ffunction-sections -Wl,--gc-sections"
+export CFLAGS+=" -Wall -g -fPIC -rdynamic ${GC_SECTIONS_FLAGS} -D_F_REMAP_MOUSE_BUTTON_TO_HWKEY_ "
export LDFLAGS+=" -Wl,--hash-style=both -Wl,--as-needed -Wl,--rpath=/usr/lib"
-# use dlog
-export CFLAGS+=" -DUSE_DLOG"
+
+export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
+
+export CFLAGS+=" -D_ENV_MOBILE_"
%ifarch %{arm}
export CFLAGS+=" -D_ENV_ARM"
for FILE in %{DEF_SUBDIRS}
do
+ if test "x${FILE}" = "xcomp-tizen" ; then
+ cd $FILE
+ export CFLAGS+=" -D_F_USE_GRAB_KEY_SET_"
+ %autogen
+ %configure --enable-hwc \
+ --prefix=/usr
+ make %{?jobs:-j%jobs}
+ cd -
+ elif test "x${FILE}" = "xscreen-reader" ; then
cd $FILE
+# export CFLAGS+=" -DENABLE_RAPID_KEY_INPUT"
%autogen
%configure --prefix=/usr
- make
+ make %{?jobs:-j%jobs}
cd -
+ else
+ cd $FILE
+ %autogen
+ %configure --prefix=/usr
+ make %{?jobs:-j%jobs}
+ cd -
+ fi
done
%install
rm -rf %{buildroot}
+# for smack rule
+mkdir -p %{buildroot}/etc/smack/accesses2.d
+cp %{_builddir}/%{buildsubdir}/e17-extra-modules.rule %{buildroot}/etc/smack/accesses2.d
+
# for license notification
mkdir -p %{buildroot}/usr/share/license
cp -a %{_builddir}/%{buildsubdir}/COPYING %{buildroot}/usr/share/license/%{name}
%files
%manifest e17-extra-modules.manifest
%defattr(-,root,root,-)
+
%{_libdir}/enlightenment/modules/comp-tizen
%{_libdir}/enlightenment/modules/e17-extra-module-accessibility
%{_libdir}/enlightenment/modules/illume2-tizen
%{_libdir}/enlightenment/modules/move-tizen
%{_libdir}/enlightenment/modules/e17-extra-module-devicemgr
%{_libdir}/enlightenment/modules/screen-reader
-%{_libdir}/enlightenment/modules/devmode-tizen
%{_datadir}/enlightenment/data/*
%{_bindir}/extndialog
%{_bindir}/*
/usr/share/license/%{name}
+/etc/smack/accesses2.d/e17-extra-modules.rule
+
+%define _unpackaged_files_terminate_build 0
projects / platform / core / uifw / e17-extra-modules.git / commitdiff