enlightenment/enlightenment
enlightenment
/
enlightenment
10
9
Fork 12
Code Issues 24 Pull Requests 2 Projects Releases Wiki Activity
enlightenment/src/modules/illume2/policies/tablet/policy.c

1516 lines
38 KiB
C
Raw Blame History

#include "e_illume.h"
#include "policy.h"
#include "e.h"
/* local function prototypes */
static void _policy_border_set_focus(E_Client *ec);
static void _policy_border_move(E_Client *ec, int x, int y);
static void _policy_border_resize(E_Client *ec, int w, int h);
static void _policy_border_hide_below(E_Client *ec);
static void _policy_zone_layout_update(E_Zone *zone);
static void _policy_zone_layout_indicator(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_quickpanel(E_Client *ec);
static void _policy_zone_layout_softkey(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_keyboard(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_home_single(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_fullscreen(E_Client *ec);
static void _policy_zone_layout_app_single(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_app_dual_top(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_app_dual_custom(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_app_dual_left(E_Client *ec, E_Illume_Config_Zone *cz, Eina_Bool force);
static void _policy_zone_layout_dialog(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_splash(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_conformant_single(E_Client *ec, E_Illume_Config_Zone *cz);
#if 0
static void _policy_zone_layout_conformant_dual_top(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_conformant_dual_custom(E_Client *ec, E_Illume_Config_Zone *cz);
static void _policy_zone_layout_conformant_dual_left(E_Client *ec, E_Illume_Config_Zone *cz);
#endif
static Eina_List *_pol_focus_stack;
/* local functions */
static void
_policy_border_set_focus(E_Client *ec)
{
if (!ec) return;
/* printf("_policy_border_set_focus %s\n", e_client_util_name_get(ec)); */
/* if focus is locked out then get out */
if (ec->lock_focus_out) return;
if ((ec->icccm.accepts_focus) || (ec->icccm.take_focus))
{
/* check E's focus settings */
if ((e_config->focus_setting == E_FOCUS_NEW_WINDOW) ||
((ec->parent) &&
((e_config->focus_setting == E_FOCUS_NEW_DIALOG) ||
((ec->parent->focused) &&
(e_config->focus_setting == E_FOCUS_NEW_DIALOG_IF_OWNER_FOCUSED)))))
{
/* if the border was hidden due to layout, we need to unhide */
if (!ec->visible) e_illume_client_show(ec);
if ((ec->iconic) && (!ec->lock_user_iconify))
e_client_uniconify(ec);
if (!ec->lock_user_stacking) evas_object_raise(ec->frame);
/* focus the border */
evas_object_focus_set(ec->frame, 1);
/* evas_object_raise(ec->frame); */
/* hide the border below this one */
_policy_border_hide_below(ec);
/* NB: since we skip needless border evals when container layout
* is called (to save cpu cycles), we need to
* signal this border that it's focused so that the edj gets
* updated.
*
* This is potentially useless as THIS policy
* makes all windows borderless anyway, but it's in here for
* completeness
e_client_focus_latest_set(ec);
if (ec->bg_object)
edje_object_signal_emit(ec->bg_object, "e,state,focused", "e");
if (ec->icon_object)
edje_object_signal_emit(ec->icon_object, "e,state,focused", "e");
e_focus_event_focus_in(ec);
*/
}
}
}
static void
_policy_border_move(E_Client *ec, int x, int y)
{
if (!ec) return;
ec->x = x;
ec->y = y;
ec->changes.pos = 1;
EC_CHANGED(ec);
}
static void
_policy_border_resize(E_Client *ec, int w, int h)
{
if (!ec) return;
ec->w = w;
ec->h = h;
e_comp_object_frame_wh_unadjust(ec->frame, ec->w, ec->h, &ec->client.w, &ec->client.h);
ec->changes.size = 1;
EC_CHANGED(ec);
}
static void
_policy_border_hide_below(E_Client *ec)
{
E_Client *b;
return;
// printf("Hide Borders Below: %s %d %d\n",
// ec->icccm.name, ec->x, ec->y);
if (!ec) return;
/* Find the windows below this one */
E_CLIENT_FOREACH(ec->comp, b)
{
if (e_client_util_ignored_get(b)) continue;
if (b->layer < E_LAYER_CLIENT_BELOW) continue;
/* skip if it's the same border */
if (b == ec) break;
/* skip if it's not on this zone */
if (b->zone != ec->zone) continue;
/* skip special borders */
if (e_illume_client_is_indicator(b)) continue;
if (e_illume_client_is_softkey(b)) continue;
if (e_illume_client_is_keyboard(b)) continue;
if (e_illume_client_is_quickpanel(b)) continue;
if (e_illume_client_is_home(b)) continue;
if ((ec->fullscreen) || (ec->need_fullscreen))
{
if (b->visible) e_illume_client_hide(b);
}
else
{
/* we need to check x/y position */
if (E_CONTAINS(ec->x, ec->y, ec->w, ec->h,
b->x, b->y, b->w, b->h))
{
if (b->visible) e_illume_client_hide(b);
}
}
}
}
#if 0
static void
_policy_border_show_below(E_Client *ec)
{
Eina_List *l;
E_Client *prev, *b;
// printf("Show Borders Below: %s %d %d\n",
// ec->icccm.class, ec->x, ec->y);
if (!ec) return;
/* printf("_policy_border_show_below %s\n", e_client_util_name_get(ec)); */
if (ec->icccm.transient_for)
{
if ((prev = e_pixmap_find_client(E_PIXMAP_TYPE_X, ec->icccm.transient_for)))
{
_policy_border_set_focus(prev);
return;
}
}
/* Find the windows below this one */
E_CLIENT_FOREACH(ec->comp, b)
{
if (e_client_util_ignored_get(b)) continue;
if (b->layer < E_LAYER_CLIENT_BELOW) continue;
if (b == ec) break;
/* skip if it's not on this zone */
if (b->zone != ec->zone) continue;
/* skip special borders */
if (e_illume_client_is_indicator(b)) continue;
if (e_illume_client_is_softkey(b)) continue;
if (e_illume_client_is_keyboard(b)) continue;
if (e_illume_client_is_quickpanel(b)) continue;
if (e_illume_client_is_home(b)) continue;
if ((ec->fullscreen) || (ec->need_fullscreen))
{
_policy_border_set_focus(b);
return;
}
else
{
/* need to check x/y position */
if (E_CONTAINS(ec->x, ec->y, ec->w, ec->h,
b->x, b->y, b->w, b->h))
{
_policy_border_set_focus(b);
return;
}
}
}
/* if we reach here, then there is a problem with showing a window below
* this one, so show previous window in stack */
EINA_LIST_REVERSE_FOREACH(_pol_focus_stack, l, prev)
{
if (prev->zone != ec->zone) continue;
_policy_border_set_focus(prev);
return;
}
/* Fallback to focusing home if all above fails */
_policy_focus_home(ec->zone);
}
#endif
static void
_policy_zone_layout_update(E_Zone *zone)
{
Eina_List *l;
E_Client *ec;
if (!zone) return;
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
/* skip borders not on this zone */
if (ec->zone != zone) continue;
/* skip special windows */
if (e_object_is_del(E_OBJECT(ec))) continue;
if (e_illume_client_is_keyboard(ec)) continue;
if (e_illume_client_is_quickpanel(ec)) continue;
/* signal a changed pos here so layout gets updated */
ec->changes.pos = 1;
EC_CHANGED(ec);
}
}
static void
_policy_zone_layout_indicator(E_Client *ec, E_Illume_Config_Zone *cz)
{
if ((!ec) || (!cz)) return;
/* grab minimum indicator size */
e_illume_client_min_get(ec, NULL, &cz->indicator.size);
/* no point in doing anything here if indicator is hidden */
if ((!ec->new_client) && (!ec->visible))
{
ecore_x_e_illume_indicator_geometry_set(ec->zone->black_win,
0, 0, 0, 0);
return;
}
/* if we are dragging, then skip it for now */
if (ec->illume.drag.drag)
{
/* when dragging indicator, we need to trigger a layout update */
ecore_x_e_illume_indicator_geometry_set(ec->zone->black_win,
0, 0, 0, 0);
_policy_zone_layout_update(ec->zone);
return;
}
// printf("\tLayout Indicator: %d\n", ec->zone->num);
/* lock indicator window from dragging if we need to */
if ((cz->mode.dual == 1) && (cz->mode.side == 0))
ecore_x_e_illume_drag_locked_set(e_client_util_win_get(ec), 0);
else
ecore_x_e_illume_drag_locked_set(e_client_util_win_get(ec), 1);
if ((ec->w != ec->zone->w) || (ec->h != cz->indicator.size))
_policy_border_resize(ec, ec->zone->w, cz->indicator.size);
if (!cz->mode.dual)
{
/* move to 0, 0 (relative to zone) if needed */
if ((ec->x != ec->zone->x) || (ec->y != ec->zone->y))
{
_policy_border_move(ec, ec->zone->x, ec->zone->y);
ecore_x_e_illume_quickpanel_position_update_send(e_client_util_win_get(ec));
}
}
else
{
if (cz->mode.side == 0)
{
/* top mode...indicator is draggable so just set X.
* in this case, the indicator itself should be responsible for
* sending the quickpanel position update message when it is
* finished dragging */
if (ec->x != ec->zone->x)
_policy_border_move(ec, ec->zone->x, ec->y);
}
else
{
/* move to 0, 0 (relative to zone) if needed */
if ((ec->x != ec->zone->x) || (ec->y != ec->zone->y))
{
_policy_border_move(ec, ec->zone->x, ec->zone->y);
ecore_x_e_illume_quickpanel_position_update_send(e_client_util_win_get(ec));
}
}
}
ecore_x_e_illume_indicator_geometry_set(ec->zone->black_win,
ec->x, ec->y,
ec->w, ec->h);
if (ec->layer != POL_INDICATOR_LAYER)
evas_object_layer_set(ec->frame, POL_INDICATOR_LAYER);
}
#define ZONE_GEOMETRY \
int x, y, w, h; \
e_zone_useful_geometry_get(ec->zone, &x, &y, &w, &h); \
x += ec->zone->x; \
y += ec->zone->y; \
static void
_border_geometry_set(E_Client *ec, int x, int y, int w, int h, int layer)
{
if ((ec->w != w) || (ec->h != h))
_policy_border_resize(ec, w, h);
if ((ec->x != x) || (ec->y != y))
_policy_border_move(ec, x, y);
if ((int)ec->layer != layer) evas_object_layer_set(ec->frame, layer);
}
static void
_policy_zone_layout_quickpanel(E_Client *ec)
{
int mh;
if (!ec) return;
e_illume_client_min_get(ec, NULL, &mh);
if ((ec->w != ec->zone->w) || (ec->h != mh))
_policy_border_resize(ec, ec->zone->w, mh);
if (ec->layer != POL_QUICKPANEL_LAYER)
evas_object_layer_set(ec->frame, POL_QUICKPANEL_LAYER);
}
static void
_policy_zone_layout_softkey(E_Client *ec, E_Illume_Config_Zone *cz)
{
int ny;
if ((!ec) || (!cz)) return;
if (!ec->visible)
{
ecore_x_e_illume_softkey_geometry_set(ec->zone->black_win, 0, 0, 0, 0);
return;
}
ZONE_GEOMETRY;
e_illume_client_min_get(ec, NULL, &cz->softkey.size);
/* if we are dragging, then skip it for now */
/* NB: Disabled currently until we confirm that softkey should be draggable */
// if (ec->illume.drag.drag) return;
if ((ec->w != w) || (ec->h != cz->softkey.size))
_policy_border_resize(ec, w, cz->softkey.size);
ny = ((ec->zone->y + ec->zone->h) - cz->softkey.size);
/* NB: not sure why yet, but on startup the border->y is reporting
* that it is already in this position...but it's actually not.
* So for now, just disable the ny check until this gets sorted out */
if ((ec->x != x) || (ec->y != ny))
_policy_border_move(ec, x, ny);
/* _border_geometry_set(ec, x, ny, nw, nh, ec, POL_CONFORMANT_LAYER); */
ecore_x_e_illume_softkey_geometry_set(ec->zone->black_win,
ec->x, ec->y,
ec->w, ec->h);
if (ec->layer != POL_SOFTKEY_LAYER) evas_object_layer_set(ec->frame, POL_SOFTKEY_LAYER);
}
#define MIN_HEIGHT 100
static Eina_Bool
_policy_layout_app_check(E_Client *ec)
{
if (!ec)
return EINA_FALSE;
if (!ec->visible)
return EINA_FALSE;
if ((ec->desk != e_desk_current_get(ec->zone)) && (!ec->sticky))
return EINA_FALSE;
return EINA_TRUE;
}
static void
_policy_keyboard_restrict(E_Client *ec, int *h)
{
int kh;
if (ec->vkbd.state > ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF)
{
e_illume_keyboard_safe_app_region_get(ec->zone, NULL, NULL, NULL, &kh);
kh -= ec->zone->h - *h;
if ((kh < *h) && (kh > MIN_HEIGHT))
*h = kh;
}
}
static void
_policy_indicator_restrict(E_Illume_Config_Zone *cz, int *y, int *h)
{
if ((cz->indicator.size) && (*y < cz->indicator.size))
{
*h -= cz->indicator.size;
*y = cz->indicator.size;
}
}
static void
_policy_softkey_restrict(E_Illume_Config_Zone *cz, int *y, int *h)
{
if ((cz->softkey.size) && ((*y + *h) > cz->softkey.size))
*h -= (*y + *h) - cz->softkey.size;
}
static void
_policy_zone_layout_keyboard(E_Client *ec, E_Illume_Config_Zone *cz)
{
int ny, layer;
if ((!ec) || (!cz) || (!ec->visible)) return;
ZONE_GEOMETRY;
e_illume_client_min_get(ec, NULL, &cz->vkbd.size);
ny = ((ec->zone->y + ec->zone->h) - cz->vkbd.size);
/* if ((ec->fullscreen) || (ec->need_fullscreen))
* layer = POL_FULLSCREEN_LAYER;
* else */
layer = POL_KEYBOARD_LAYER;
_border_geometry_set(ec, x, ny, w, cz->vkbd.size, layer);
}
static void
_policy_zone_layout_home_single(E_Client *ec, E_Illume_Config_Zone *cz)
{
if ((!ec) || (!cz) || (!ec->visible)) return;
ZONE_GEOMETRY;
_policy_indicator_restrict(cz, &y, &h);
_border_geometry_set(ec, x, y, w, h, POL_HOME_LAYER);
}
static void
_policy_zone_layout_fullscreen(E_Client *ec)
{
if (!_policy_layout_app_check(ec)) return;
ZONE_GEOMETRY;
_policy_keyboard_restrict(ec, &h);
_border_geometry_set(ec, x, y, w, h, POL_FULLSCREEN_LAYER);
}
static void
_policy_zone_layout_app_single(E_Client *ec, E_Illume_Config_Zone *cz)
{
if (!_policy_layout_app_check(ec)) return;
ZONE_GEOMETRY;
_policy_keyboard_restrict(ec, &h);
_policy_indicator_restrict(cz, &y, &h);
_policy_softkey_restrict(cz, &y, &h);
_border_geometry_set(ec, x, y, w, h, POL_APP_LAYER);
}
static void
_policy_zone_layout_app_dual_top(E_Client *ec, E_Illume_Config_Zone *cz)
{
E_Client *ec2;
if (!_policy_layout_app_check(ec)) return;
ZONE_GEOMETRY;
_policy_keyboard_restrict(ec, &h);
_policy_indicator_restrict(cz, &y, &h);
_policy_softkey_restrict(cz, &y, &h);
ec2 = e_illume_client_at_xy_get(ec->zone, x, y);
if ((ec2) && (ec2 != ec))
{
if ((ec->focused) && (ec->vkbd.state > ECORE_X_VIRTUAL_KEYBOARD_STATE_OFF))
_border_geometry_set(ec2, x, h/2 + y, w, h/2, POL_APP_LAYER);
else
y += h/2;
}
_border_geometry_set(ec, x, y, w, h/2, POL_APP_LAYER);
}
static void
_policy_zone_layout_app_dual_custom(E_Client *ec, E_Illume_Config_Zone *cz)
{
E_Client *app;
int iy, ny, nh;
if (!_policy_layout_app_check(ec)) return;
ZONE_GEOMETRY;
e_illume_client_indicator_pos_get(ec->zone, NULL, &iy);
ny = ec->zone->y;
nh = iy;
app = e_illume_client_at_xy_get(ec->zone, ec->zone->x, ec->zone->y);
if ((app) && (ec != app))
{
ny = (iy + cz->indicator.size);
nh = ((ec->zone->y + ec->zone->h) - ny - cz->softkey.size);
}
_border_geometry_set(ec, x, ny, w, nh, POL_APP_LAYER);
}
static void
_policy_zone_layout_app_dual_left(E_Client *ec, E_Illume_Config_Zone *cz, Eina_Bool force)
{
E_Client *ec2;
int ky, kh, nx, nw;
if (!_policy_layout_app_check(ec)) return;
ZONE_GEOMETRY;
e_illume_keyboard_safe_app_region_get(ec->zone, NULL, &ky, NULL, &kh);
if (kh >= ec->zone->h)
kh = (kh - cz->indicator.size - cz->softkey.size);
else
kh = (kh - cz->indicator.size);
nx = x;
nw = w / 2;
if (!force)
{
/* see if there is a border already there. if so, place at right */
ec2 = e_illume_client_at_xy_get(ec->zone, nx, y);
if ((ec2) && (ec != ec2)) nx = x + nw;
}
_border_geometry_set(ec, nx, y, nw, kh, POL_APP_LAYER);
}
static void
_policy_zone_layout_dialog(E_Client *ec, E_Illume_Config_Zone *cz)
{
E_Client *parent;
int mw, mh, nx, ny;
/* if (!_policy_layout_app_check(ec)) return; */
if ((!ec) || (!cz)) return;
printf("place dialog %d - %dx%d\n", ec->placed, ec->w, ec->h);
if (ec->placed)
return;
ZONE_GEOMETRY;
mw = ec->w;
mh = ec->h;
if (e_illume_client_is_fixed_size(ec))
{
if (mw > w) mw = w;
if (mh > h) mh = h;
}
else
{
if (w * 2/3 > ec->w)
mw = w * 2/3;
if (h * 2/3 > ec->h)
mh = h * 2/3;
}
parent = e_illume_client_parent_get(ec);
if ((!parent) || (cz->mode.dual == 1))
{
nx = (x + ((w - mw) / 2));
ny = (y + ((h - mh) / 2));
}
else
{
if (mw > parent->w) mw = parent->w;
if (mh > parent->h) mh = parent->h;
nx = (parent->x + ((parent->w - mw) / 2));
ny = (parent->y + ((parent->h - mh) / 2));
}
ec->placed = 1;
_border_geometry_set(ec, nx, ny, mw, mh, POL_DIALOG_LAYER);
printf("set geom %d %d\n", mw, mh);
}
static void
_policy_zone_layout_splash(E_Client *ec, E_Illume_Config_Zone *cz)
{
_policy_zone_layout_dialog(ec, cz);
if (ec->layer != POL_SPLASH_LAYER) evas_object_layer_set(ec->frame, POL_SPLASH_LAYER);
}
static void
_policy_zone_layout_conformant_single(E_Client *ec, E_Illume_Config_Zone *cz __UNUSED__)
{
if (!_policy_layout_app_check(ec)) return;
_border_geometry_set(ec, ec->zone->x, ec->zone->y,
ec->zone->w, ec->zone->h,
POL_CONFORMANT_LAYER);
}
#if 0
typedef struct _App_Desk App_Desk;
struct _App_Desk
{
E_Desk *desk;
const char *class;
Eina_List *borders;
};
static Eina_List *desks = NULL;
#define EINA_LIST_FIND(_list, _item, _match) \
{ \
Eina_List *_l; \
EINA_LIST_FOREACH(_list, _l, _item) \
if (_match) break; \
}
#endif
/* policy functions */
void
_policy_border_add(E_Client *ec)
{
// printf("Border added: %s\n", ec->icccm.class);
if (!ec) return;
/* NB: this call sets an atom on the window that specifices the zone.
* the logic here is that any new windows created can access the zone
* window by a 'get' call. This is useful for elementary apps as they
* normally would not have access to the zone window. Typical use case
* is for indicator & softkey windows so that they can send messages
* that apply to their respective zone only. Example: softkey sends close
* messages (or back messages to cycle focus) that should pertain just
* to it's current zone */
ecore_x_e_illume_zone_set(e_client_util_win_get(ec), ec->zone->black_win);
if (e_illume_client_is_keyboard(ec))
{
ec->sticky = 1;
e_hints_window_sticky_set(ec, 1);
}
if (e_illume_client_is_home(ec))
{
ec->sticky = 1;
e_hints_window_sticky_set(ec, 1);
}
if (e_illume_client_is_indicator(ec))
{
ec->sticky = 1;
e_hints_window_sticky_set(ec, 1);
}
if (e_illume_client_is_softkey(ec))
{
ec->sticky = 1;
e_hints_window_sticky_set(ec, 1);
}
/* ignore stolen borders. These are typically quickpanel or keyboards */
if (ec->stolen) return;
/* if this is a fullscreen window, than we need to hide indicator window */
/* NB: we could use the e_illume_client_is_fullscreen function here
* but we save ourselves a function call this way */
if ((ec->fullscreen) || (ec->need_fullscreen))
{
E_Client *ind, *sft;
if ((ind = e_illume_client_indicator_get(ec->zone)))
{
if (ind->visible) e_illume_client_hide(ind);
}
if ((sft = e_illume_client_softkey_get(ec->zone)))
{
if (e_illume_client_is_conformant(ec))
{
if (sft->visible)
e_illume_client_hide(sft);
else if (!sft->visible)
e_illume_client_show(sft);
}
}
}
#if 0
if (ec->icccm.class)
{
Eina_List *l;
App_Desk *d;
EINA_LIST_FIND(desks, d, (d->class == ec->icccm.class));
if (!d)
{
d = E_NEW(App_Desk, 1);
d->desk
}
d->borders = eina_list_append(d->borders, ec);
e_client_desk_set(ec, d->desk);
}
#endif
/* Add this border to our focus stack if it can accept or take focus */
if ((ec->icccm.accepts_focus) || (ec->icccm.take_focus))
_pol_focus_stack = eina_list_append(_pol_focus_stack, ec);
if ((e_illume_client_is_softkey(ec)) || (e_illume_client_is_indicator(ec)))
_policy_zone_layout_update(ec->zone);
else
{
/* set focus on new border if we can */
_policy_border_set_focus(ec);
}
}
void
_policy_border_del(E_Client *ec)
{
// printf("Policy Border deleted: %s\n", ec->icccm.class);
if (!ec) return;
/* if this is a fullscreen window, than we need to show indicator window */
/* NB: we could use the e_illume_client_is_fullscreen function here
* but we save ourselves a function call this way */
if ((ec->fullscreen) || (ec->need_fullscreen))
{
E_Client *ind;
/* try to get the Indicator on this zone */
if ((ind = e_illume_client_indicator_get(ec->zone)))
{
if (!ind->visible) e_illume_client_show(ind);
}
_policy_zone_layout_update(ec->zone);
}
/* remove from focus stack */
if ((ec->icccm.accepts_focus) || (ec->icccm.take_focus))
_pol_focus_stack = eina_list_remove(_pol_focus_stack, ec);
if (e_illume_client_is_softkey(ec))
{
E_Illume_Config_Zone *cz;
cz = e_illume_zone_config_get(ec->zone->num);
cz->softkey.size = 0;
_policy_zone_layout_update(ec->zone);
}
else if (e_illume_client_is_indicator(ec))
{
E_Illume_Config_Zone *cz;
cz = e_illume_zone_config_get(ec->zone->num);
cz->indicator.size = 0;
_policy_zone_layout_update(ec->zone);
}
/* else
* {
* _policy_border_show_below(ec);
* } */
}
void
_policy_border_focus_in(E_Client *ec __UNUSED__)
{
E_Client *ind;
// printf("Border focus in: %s\n", ec->icccm.name);
if ((ec->fullscreen) || (ec->need_fullscreen))
{
/* try to get the Indicator on this zone */
if ((ind = e_illume_client_indicator_get(ec->zone)))
{
/* we have the indicator, show it if needed */
if (ind->visible) e_illume_client_hide(ind);
}
}
else
{
/* try to get the Indicator on this zone */
if ((ind = e_illume_client_indicator_get(ec->zone)))
{
/* we have the indicator, show it if needed */
if (!ind->visible) e_illume_client_show(ind);
}
}
_policy_zone_layout_update(ec->zone);
}
void
_policy_border_focus_out(E_Client *ec)
{
// printf("Border focus out: %s\n", ec->icccm.name);
if (!ec) return;
/* NB: if we got this focus_out event on a deleted border, we check if
* it is a transient (child) of another window. If it is, then we
* transfer focus back to the parent window */
if (e_object_is_del(E_OBJECT(ec)))
{
if (e_illume_client_is_dialog(ec))
{
E_Client *parent;
if ((parent = e_illume_client_parent_get(ec)))
_policy_border_set_focus(parent);
}
}
}
void
_policy_border_activate(E_Client *ec)
{
E_Client *sft;
// printf("Border Activate: %s\n", ec->icccm.name);
if (!ec) return;
/* NB: stolen borders may or may not need focus call...have to test */
if (ec->stolen) return;
/* conformant windows hide the softkey */
if ((sft = e_illume_client_softkey_get(ec->zone)))
{
if (e_illume_client_is_conformant(ec))
{
if (sft->visible) e_illume_client_hide(sft);
}
else
{
if (!sft->visible) e_illume_client_show(sft);
}
}
/* NB: We cannot use our set_focus function here because it does,
* occasionally fall through wrt E's focus policy, so cherry pick the good
* parts and use here :) */
if (ec->desk != e_desk_current_get(ec->zone))
e_desk_show(ec->desk);
/* if the border is iconified then uniconify if allowed */
if ((ec->iconic) && (!ec->lock_user_iconify))
e_client_uniconify(ec);
/* set very high layer for this window as it needs attention and thus
* should show above everything */
evas_object_layer_set(ec->frame, POL_ACTIVATE_LAYER);
/* if we can raise the border do it */
if (!ec->lock_user_stacking) evas_object_raise(ec->frame);
/* focus the border */
evas_object_focus_set(ec->frame, 1);
/* NB: since we skip needless border evals when container layout
* is called (to save cpu cycles), we need to
* signal this border that it's focused so that the edj gets
* updated.
*
* This is potentially useless as THIS policy
* makes all windows borderless anyway, but it's in here for
* completeness
e_client_focus_latest_set(ec);
if (ec->bg_object)
edje_object_signal_emit(ec->bg_object, "e,state,focused", "e");
if (ec->icon_object)
edje_object_signal_emit(ec->icon_object, "e,state,focused", "e");
e_focus_event_focus_in(ec);
*/
}
static Eina_Bool
_policy_border_is_dialog(E_Client *ec)
{
if (e_illume_client_is_dialog(ec))
return EINA_TRUE;
if (ec->e.state.centered)
return EINA_TRUE;
if (ec->internal)
{
if (ec->icccm.class)
{
if (!strncmp(ec->icccm.class, "Illume", 6))
return EINA_FALSE;
if (!strncmp(ec->icccm.class, "e_fwin", 6))
return EINA_FALSE;
if (!strncmp(ec->icccm.class, "every", 5))
return EINA_FALSE;
}
return EINA_TRUE;
}
return EINA_FALSE;
}
void
_policy_border_post_fetch(E_Client *ec)
{
if (!ec) return;
/* NB: for this policy we disable all remembers set on a border */
if (ec->remember) e_remember_del(ec->remember);
ec->remember = NULL;
if (_policy_border_is_dialog(ec))
{
return;
}
else if (e_illume_client_is_fixed_size(ec))
{
return;
}
else if (!ec->borderless)
{
ec->borderless = 1;
ec->border.changed = 1;
}
}
void
_policy_border_post_assign(E_Client *ec)
{
if (!ec) return;
ec->internal_no_remember = 1;
if (_policy_border_is_dialog(ec) ||
e_illume_client_is_fixed_size(ec))
return;
/* do not allow client to change these properties */
ec->lock_client_size = 1;
ec->lock_client_shade = 1;
ec->lock_client_maximize = 1;
ec->lock_client_location = 1;
ec->lock_client_stacking = 1;
/* do not allow the user to change these properties */
/* ec->lock_user_location = 1;
* ec->lock_user_size = 1;
* ec->lock_user_shade = 1; */
/* clear any centered states */
/* NB: this is mainly needed for E's main config dialog */
ec->e.state.centered = 0;
/* lock the border type so user/client cannot change */
ec->lock_border = 1;
/* disable e's placement (and honoring of icccm.request_pos) */
ec->placed = 1;
}
void
_policy_border_show(E_Client *ec)
{
if (!ec) return;
/* printf("_policy_border_show %s\n", e_client_util_name_get(ec)); */
if (!ec->icccm.name) return;
// printf("Border Show: %s\n", ec->icccm.class);
/* trap for special windows so we can ignore hides below them */
if (e_illume_client_is_indicator(ec)) return;
if (e_illume_client_is_softkey(ec)) return;
if (e_illume_client_is_quickpanel(ec)) return;
if (e_illume_client_is_keyboard(ec)) return;
_policy_border_hide_below(ec);
}
/* called on E_CLIENT_HOOK_CONTAINER_LAYOUT (after e_border/eval0) */
void
_policy_zone_layout(E_Zone *zone)
{
E_Illume_Config_Zone *cz;
Eina_List *l;
E_Client *ec;
if (!zone) return;
cz = e_illume_zone_config_get(zone->num);
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
if (e_object_is_del(E_OBJECT(ec))) continue;
if (ec->zone != zone) continue;
if ((!ec->new_client) && (!ec->changes.pos) && (!ec->changes.size) &&
(!ec->changes.visible) &&
(!ec->need_shape_export) && (!ec->need_shape_merge)) continue;
if (e_illume_client_is_indicator(ec))
_policy_zone_layout_indicator(ec, cz);
else if (e_illume_client_is_quickpanel(ec))
_policy_zone_layout_quickpanel(ec);
else if (e_illume_client_is_softkey(ec))
_policy_zone_layout_softkey(ec, cz);
else if (e_illume_client_is_keyboard(ec))
_policy_zone_layout_keyboard(ec, cz);
else if (e_illume_client_is_home(ec))
_policy_zone_layout_home_single(ec, cz);
else if ((ec->fullscreen) || (ec->need_fullscreen))
_policy_zone_layout_fullscreen(ec);
else if (e_illume_client_is_splash(ec))
_policy_zone_layout_splash(ec, cz);
else if (_policy_border_is_dialog(ec))
_policy_zone_layout_dialog(ec, cz);
else if (e_illume_client_is_conformant(ec))
_policy_zone_layout_conformant_single(ec, cz);
else if (e_illume_client_is_fixed_size(ec))
_policy_zone_layout_dialog(ec, cz);
else if (ec->internal && ec->icccm.class &&
(!strcmp(ec->icccm.class, "everything-window")))
{
if (ec->vkbd.state == ECORE_X_VIRTUAL_KEYBOARD_STATE_ON)
_policy_zone_layout_app_single(ec, cz);
/* else
* _policy_zone_layout_app_dual_left(ec, cz, EINA_TRUE); */
if (ec->layer != POL_ACTIVATE_LAYER)
evas_object_layer_set(ec->frame, POL_ACTIVATE_LAYER);
/* if (ec->layer != POL_SPLASH_LAYER)
* evas_object_layer_set(ec->frame, POL_SPLASH_LAYER); */
}
else if (ec->e.state.centered)
_policy_zone_layout_dialog(ec, cz);
else if (!cz->mode.dual)
_policy_zone_layout_app_single(ec, cz);
else
{
if (cz->mode.side == 0)
{
int ty;
/* grab the indicator position so we can tell if it
* is in a custom position or not (user dragged it) */
e_illume_client_indicator_pos_get(ec->zone, NULL, &ty);
if (ty <= ec->zone->y)
_policy_zone_layout_app_dual_top(ec, cz);
else
_policy_zone_layout_app_dual_custom(ec, cz);
}
else
_policy_zone_layout_app_dual_left(ec, cz, EINA_FALSE);
}
}
}
void
_policy_zone_move_resize(E_Zone *zone)
{
Eina_List *l;
E_Client *ec;
if (!zone) return;
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
if (ec->zone != zone) continue;
ec->changes.pos = 1;
EC_CHANGED(ec);
}
}
void
_policy_zone_mode_change(E_Zone *zone, Ecore_X_Atom mode)
{
E_Illume_Config_Zone *cz;
/* Eina_List *homes = NULL; */
E_Client *ec;
/* int count; */
if (!zone) return;
cz = e_illume_zone_config_get(zone->num);
if (mode == ECORE_X_ATOM_E_ILLUME_MODE_SINGLE)
cz->mode.dual = 0;
else
{
cz->mode.dual = 1;
if (mode == ECORE_X_ATOM_E_ILLUME_MODE_DUAL_TOP)
cz->mode.side = 0;
else if (mode == ECORE_X_ATOM_E_ILLUME_MODE_DUAL_LEFT)
cz->mode.side = 1;
}
e_config_save_queue();
/* lock indicator window from dragging if we need to */
ec = e_illume_client_indicator_get(zone);
if (ec)
{
/* only dual-top mode can drag */
if ((cz->mode.dual == 1) && (cz->mode.side == 0))
{
/* only set locked if we need to */
if (ec->illume.drag.locked != 0)
ecore_x_e_illume_drag_locked_set(e_client_util_win_get(ec), 0);
}
else
{
/* only set locked if we need to */
if (ec->illume.drag.locked != 1)
ecore_x_e_illume_drag_locked_set(e_client_util_win_get(ec), 1);
}
}
#if 0 /* split home window? wtf?! go home! */
if (!(homes = e_illume_client_home_borders_get(zone))) return;
count = eina_list_count(homes);
/* create a new home window (if needed) for dual mode */
if (cz->mode.dual == 1)
{
if (count < 2)
ecore_x_e_illume_home_new_send(zone->black_win);
}
else if (cz->mode.dual == 0)
{
/* if we went to single mode, delete any extra home windows */
if (count >= 2)
{
E_Client *home;
/* try to get a home window on this zone and remove it */
if ((home = e_illume_client_home_get(zone)))
ecore_x_e_illume_home_del_send(e_client_util_win_get(home));
}
}
#endif
_policy_zone_layout_update(zone);
}
void
_policy_zone_close(E_Zone *zone)
{
E_Client *ec;
if (!zone) return;
if (!(ec = e_client_focused_get())) return;
if (ec->zone != zone) return;
/* close this border */
e_client_act_close_begin(ec);
}
void
_policy_drag_start(E_Client *ec)
{
if (!ec) return;
if (ec->stolen) return;
ecore_x_e_illume_drag_set(e_client_util_win_get(ec), 1);
ecore_x_e_illume_drag_set(ec->zone->black_win, 1);
}
void
_policy_drag_end(E_Client *ec)
{
// printf("Drag end\n");
if (!ec) return;
if (ec->stolen) return;
/* set property on this border to say we are done dragging */
ecore_x_e_illume_drag_set(e_client_util_win_get(ec), 0);
/* set property on zone window that a drag is finished */
ecore_x_e_illume_drag_set(ec->zone->black_win, 0);
}
void
_policy_focus_back(E_Zone *zone)
{
Eina_List *l, *fl = NULL;
E_Client *ec, *fbd;
if (!zone) return;
if (eina_list_count(_pol_focus_stack) < 1) return;
// printf("Focus back\n");
EINA_LIST_REVERSE_FOREACH(_pol_focus_stack, l, ec)
{
if (ec->zone != zone) continue;
fl = eina_list_append(fl, ec);
}
if (!(fbd = e_client_focused_get())) return;
if (fbd->parent) return;
EINA_LIST_REVERSE_FOREACH(fl, l, ec)
{
if ((fbd) && (ec == fbd))
{
E_Client *b;
if ((l->next) && (b = l->next->data))
{
_policy_border_set_focus(b);
break;
}
else
{
/* we've reached the end of the list. Set focus to first */
if ((b = eina_list_nth(fl, 0)))
{
_policy_border_set_focus(b);
break;
}
}
}
}
eina_list_free(fl);
}
void
_policy_focus_forward(E_Zone *zone)
{
Eina_List *l, *fl = NULL;
E_Client *ec, *fbd;
if (!zone) return;
if (eina_list_count(_pol_focus_stack) < 1) return;
// printf("Focus forward\n");
EINA_LIST_FOREACH(_pol_focus_stack, l, ec)
{
if (ec->zone != zone) continue;
fl = eina_list_append(fl, ec);
}
if (!(fbd = e_client_focused_get())) return;
if (fbd->parent) return;
EINA_LIST_FOREACH(fl, l, ec)
{
if ((fbd) && (ec == fbd))
{
E_Client *b;
if ((l->next) && (b = l->next->data))
{
_policy_border_set_focus(b);
break;
}
else
{
/* we've reached the end of the list. Set focus to first */
if ((b = eina_list_nth(fl, 0)))
{
_policy_border_set_focus(b);
break;
}
}
}
}
eina_list_free(fl);
}
void
_policy_focus_home(E_Zone *zone)
{
E_Client *ec;
if (!zone) return;
if (!(ec = e_illume_client_home_get(zone))) return;
_policy_border_set_focus(ec);
}
void
_policy_property_change(Ecore_X_Event_Window_Property *event)
{
if (event->atom == ECORE_X_ATOM_NET_WM_STATE)
{
E_Client *ec, *ind;
if (!(ec = e_pixmap_find_client(E_PIXMAP_TYPE_X, event->win))) return;
/* not interested in stolen or invisible borders */
if ((ec->stolen) || (!ec->visible)) return;
/* make sure the border has a name or class */
/* NB: this check is here because some E borders get State Changes
* 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 ((!ec->icccm.name) || (!ec->icccm.class)) return;
/* NB: If we have reached this point, then it should be a fullscreen
* border that has toggled fullscreen on/off */
/* try to get the Indicator on this zone */
if (!(ind = e_illume_client_indicator_get(ec->zone))) return;
/* if we are fullscreen, hide the indicator...else we show it */
/* NB: we could use the e_illume_client_is_fullscreen function here
* but we save ourselves a function call this way */
if ((ec->fullscreen) || (ec->need_fullscreen))
{
if (ind->visible)
{
e_illume_client_hide(ind);
_policy_zone_layout_update(ec->zone);
}
}
else
{
if (!ind->visible)
{
e_illume_client_show(ind);
_policy_zone_layout_update(ec->zone);
}
}
}
else if (event->atom == ECORE_X_ATOM_E_ILLUME_INDICATOR_GEOMETRY)
{
Eina_List *l;
E_Zone *zone;
E_Client *ec;
int x, y, w, h;
if (!(zone = e_util_zone_window_find(event->win))) return;
if (!(ec = e_illume_client_indicator_get(zone))) return;
x = ec->x;
y = ec->y;
w = ec->w;
h = ec->h;
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
if (ec->zone != zone) continue;
if (!e_illume_client_is_conformant(ec)) continue;
/* set indicator geometry on conformant window */
/* NB: This is needed so that conformant apps get told about
* the indicator size/position...else they have no way of
* knowing that the geometry has been updated */
ecore_x_e_illume_indicator_geometry_set(e_client_util_win_get(ec), x, y, w, h);
}
}
else if (event->atom == ECORE_X_ATOM_E_ILLUME_SOFTKEY_GEOMETRY)
{
Eina_List *l;
E_Zone *zone;
E_Client *ec;
int x, y, w, h;
if (!(zone = e_util_zone_window_find(event->win))) return;
if (!(ec = e_illume_client_softkey_get(zone))) return;
x = ec->x;
y = ec->y;
w = ec->w;
h = ec->h;
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
if (ec->zone != zone) continue;
if (!e_illume_client_is_conformant(ec)) continue;
/* set softkey geometry on conformant window */
/* NB: This is needed so that conformant apps get told about
* the softkey size/position...else they have no way of
* knowing that the geometry has been updated */
ecore_x_e_illume_softkey_geometry_set(e_client_util_win_get(ec), x, y, w, h);
}
}
else if (event->atom == ECORE_X_ATOM_E_ILLUME_KEYBOARD_GEOMETRY)
{
Eina_List *l;
E_Zone *zone;
E_Illume_Keyboard *kbd;
E_Client *ec;
int x, y, w, h;
if (!(zone = e_util_zone_window_find(event->win))) return;
if (!(kbd = e_illume_keyboard_get())) return;
if (!kbd->client) return;
x = kbd->client->x;
w = kbd->client->w;
h = kbd->client->h;
/* adjust Y for keyboard visibility because keyboard uses fx_offset */
y = 0;
#warning this is totally broken on so many levels
//if (kbd->client->frame &&
//(!e_util_strcmp(edje_object_part_state_get(kbd->client->cw->effect_obj, "mover", NULL), "custom")))
//y = kbd->client->y;
/* look for conformant borders */
EINA_LIST_FOREACH(zone->comp->clients, l, ec)
{
if (e_client_util_ignored_get(ec)) continue;
if (ec->zone != zone) continue;
if (!e_illume_client_is_conformant(ec)) continue;
/* set keyboard geometry on conformant window */
/* NB: This is needed so that conformant apps get told about
* the keyboard size/position...else they have no way of
* knowing that the geometry has been updated */
ecore_x_e_illume_keyboard_geometry_set(e_client_util_win_get(ec), x, y, w, h);
}
}
else if (event->atom == ATM_ENLIGHTENMENT_SCALE)
{
const Eina_List *l;
E_Comp *comp;
EINA_LIST_FOREACH(e_comp_list(), l, comp)
{
Eina_List *zl;
E_Zone *zone;
if (event->win != comp->man->root) continue;
EINA_LIST_FOREACH(comp->zones, zl, zone)
_policy_zone_layout_update(zone);
}
}
}
Reference in New Issue View Git Blame Copy Permalink