2004-11-24 19:37:45 -08:00
|
|
|
#include "e.h"
|
2005-01-03 01:34:24 -08:00
|
|
|
|
|
|
|
/* E_Desk is a child object of E_Zone. A desk is essentially a background
|
|
|
|
* and an associated set of client windows. Each zone can have an arbitrary
|
|
|
|
* number of desktops.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void _e_desk_free(E_Desk *desk);
|
2009-09-05 05:43:44 -07:00
|
|
|
static void _e_desk_event_desk_show_free(void *data, void *ev);
|
|
|
|
static void _e_desk_event_desk_before_show_free(void *data, void *ev);
|
|
|
|
static void _e_desk_event_desk_after_show_free(void *data, void *ev);
|
|
|
|
static void _e_desk_event_desk_deskshow_free(void *data, void *ev);
|
|
|
|
static void _e_desk_event_desk_name_change_free(void *data, void *ev);
|
2006-09-01 08:37:23 -07:00
|
|
|
static void _e_desk_show_begin(E_Desk *desk, int mode, int dx, int dy);
|
|
|
|
static void _e_desk_show_end(E_Desk *desk);
|
2010-06-24 09:19:12 -07:00
|
|
|
static Eina_Bool _e_desk_show_animator(void *data);
|
2006-09-01 08:37:23 -07:00
|
|
|
static void _e_desk_hide_begin(E_Desk *desk, int mode, int dx, int dy);
|
|
|
|
static void _e_desk_hide_end(E_Desk *desk);
|
2010-06-24 09:19:12 -07:00
|
|
|
static Eina_Bool _e_desk_hide_animator(void *data);
|
2006-09-01 08:37:23 -07:00
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI int E_EVENT_DESK_SHOW = 0;
|
2008-06-05 03:52:13 -07:00
|
|
|
EAPI int E_EVENT_DESK_BEFORE_SHOW = 0;
|
2009-02-25 14:21:46 -08:00
|
|
|
EAPI int E_EVENT_DESK_AFTER_SHOW = 0;
|
2006-07-22 15:25:04 -07:00
|
|
|
EAPI int E_EVENT_DESK_DESKSHOW = 0;
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI int E_EVENT_DESK_NAME_CHANGE = 0;
|
2005-02-15 04:11:31 -08:00
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI int
|
2005-01-05 02:37:53 -08:00
|
|
|
e_desk_init(void)
|
|
|
|
{
|
2005-02-15 04:11:31 -08:00
|
|
|
E_EVENT_DESK_SHOW = ecore_event_type_new();
|
2008-06-05 03:52:13 -07:00
|
|
|
E_EVENT_DESK_BEFORE_SHOW = ecore_event_type_new();
|
2009-02-25 14:21:46 -08:00
|
|
|
E_EVENT_DESK_AFTER_SHOW = ecore_event_type_new();
|
2006-07-22 15:25:04 -07:00
|
|
|
E_EVENT_DESK_DESKSHOW = ecore_event_type_new();
|
2005-09-05 16:14:58 -07:00
|
|
|
E_EVENT_DESK_NAME_CHANGE = ecore_event_type_new();
|
2005-01-05 02:37:53 -08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI int
|
2005-01-05 02:37:53 -08:00
|
|
|
e_desk_shutdown(void)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
2005-01-03 01:34:24 -08:00
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI E_Desk *
|
2005-01-08 06:41:21 -08:00
|
|
|
e_desk_new(E_Zone *zone, int x, int y)
|
2005-01-03 01:34:24 -08:00
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Desk *desk;
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *l;
|
2009-08-21 08:08:49 -07:00
|
|
|
E_Config_Desktop_Name *cfname;
|
2007-04-25 04:28:35 -07:00
|
|
|
char name[40];
|
|
|
|
int ok;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-05 00:39:25 -08:00
|
|
|
E_OBJECT_CHECK_RETURN(zone, NULL);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-21 22:58:34 -08:00
|
|
|
desk = E_OBJECT_ALLOC(E_Desk, E_DESK_TYPE, _e_desk_free);
|
2005-01-03 01:34:24 -08:00
|
|
|
if (!desk) return NULL;
|
|
|
|
|
|
|
|
desk->zone = zone;
|
2005-04-08 17:13:09 -07:00
|
|
|
desk->x = x;
|
|
|
|
desk->y = y;
|
2005-06-19 12:00:04 -07:00
|
|
|
|
2007-04-25 04:28:35 -07:00
|
|
|
/* Get current desktop's name */
|
2005-08-05 21:00:03 -07:00
|
|
|
ok = 0;
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
|
|
|
if ((cfname->container >= 0) &&
|
2010-06-24 09:19:12 -07:00
|
|
|
((int) zone->container->num != cfname->container)) continue;
|
2005-08-05 21:00:03 -07:00
|
|
|
if ((cfname->zone >= 0) &&
|
2010-06-24 09:19:12 -07:00
|
|
|
((int) zone->num != cfname->zone)) continue;
|
2008-07-06 18:03:33 -07:00
|
|
|
if ((cfname->desk_x != desk->x) || (cfname->desk_y != desk->y))
|
|
|
|
continue;
|
2008-10-15 08:12:56 -07:00
|
|
|
desk->name = eina_stringshare_add(cfname->name);
|
2005-08-05 21:00:03 -07:00
|
|
|
ok = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ok)
|
|
|
|
{
|
|
|
|
snprintf(name, sizeof(name), _(e_config->desktop_default_name), x, y);
|
2008-10-15 08:12:56 -07:00
|
|
|
desk->name = eina_stringshare_add(name);
|
2005-08-05 21:00:03 -07:00
|
|
|
}
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-03 01:34:24 -08:00
|
|
|
return desk;
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-03 01:34:24 -08:00
|
|
|
e_desk_name_set(E_Desk *desk, const char *name)
|
|
|
|
{
|
2005-09-05 16:14:58 -07:00
|
|
|
E_Event_Desk_Name_Change *ev;
|
|
|
|
|
2005-01-03 01:34:24 -08:00
|
|
|
E_OBJECT_CHECK(desk);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
|
2008-10-15 08:12:56 -07:00
|
|
|
if (desk->name) eina_stringshare_del(desk->name);
|
|
|
|
desk->name = eina_stringshare_add(name);
|
2005-09-05 16:14:58 -07:00
|
|
|
|
|
|
|
ev = E_NEW(E_Event_Desk_Name_Change, 1);
|
|
|
|
ev->desk = desk;
|
|
|
|
e_object_ref(E_OBJECT(desk));
|
2007-04-25 04:28:35 -07:00
|
|
|
ecore_event_add(E_EVENT_DESK_NAME_CHANGE, ev,
|
2009-09-05 05:43:44 -07:00
|
|
|
_e_desk_event_desk_name_change_free, NULL);
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2006-03-02 04:03:48 -08:00
|
|
|
e_desk_name_add(int container, int zone, int desk_x, int desk_y, const char *name)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
|
|
|
E_Config_Desktop_Name *cfname;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-08-05 21:00:03 -07:00
|
|
|
e_desk_name_del(container, zone, desk_x, desk_y);
|
|
|
|
cfname = E_NEW(E_Config_Desktop_Name, 1);
|
|
|
|
cfname->container = container;
|
|
|
|
cfname->zone = zone;
|
|
|
|
cfname->desk_x = desk_x;
|
|
|
|
cfname->desk_y = desk_y;
|
2008-10-15 08:12:56 -07:00
|
|
|
if (name) cfname->name = eina_stringshare_add(name);
|
2008-10-22 04:49:33 -07:00
|
|
|
e_config->desktop_names = eina_list_append(e_config->desktop_names, cfname);
|
2005-08-05 21:00:03 -07:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-08-05 21:00:03 -07:00
|
|
|
e_desk_name_del(int container, int zone, int desk_x, int desk_y)
|
|
|
|
{
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *l = NULL;
|
2009-08-21 08:08:49 -07:00
|
|
|
E_Config_Desktop_Name *cfname = NULL;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
|
|
|
if ((cfname->container == container) && (cfname->zone == zone) &&
|
|
|
|
(cfname->desk_x == desk_x) && (cfname->desk_y == desk_y))
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
e_config->desktop_names =
|
2008-10-22 04:49:33 -07:00
|
|
|
eina_list_remove_list(e_config->desktop_names, l);
|
2008-10-15 08:12:56 -07:00
|
|
|
if (cfname->name) eina_stringshare_del(cfname->name);
|
2005-08-05 21:00:03 -07:00
|
|
|
free(cfname);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-08-05 21:00:03 -07:00
|
|
|
e_desk_name_update(void)
|
|
|
|
{
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *m, *c, *z, *l;
|
2005-08-05 21:00:03 -07:00
|
|
|
E_Manager *man;
|
|
|
|
E_Container *con;
|
|
|
|
E_Zone *zone;
|
|
|
|
E_Desk *desk;
|
2009-08-21 08:08:49 -07:00
|
|
|
E_Config_Desktop_Name *cfname;
|
2005-08-05 21:00:03 -07:00
|
|
|
int d_x, d_y, ok;
|
|
|
|
char name[40];
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_manager_list(), m, man)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(man->containers, c, con)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(con->zones, z, zone)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
|
|
|
for (d_x = 0; d_x < zone->desk_x_count; d_x++)
|
|
|
|
{
|
|
|
|
for (d_y = 0; d_y < zone->desk_y_count; d_y++)
|
|
|
|
{
|
|
|
|
desk = zone->desks[d_x + zone->desk_x_count * d_y];
|
|
|
|
ok = 0;
|
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
|
2005-08-05 21:00:03 -07:00
|
|
|
{
|
|
|
|
if ((cfname->container >= 0) &&
|
2010-06-24 09:19:12 -07:00
|
|
|
((int) con->num != cfname->container)) continue;
|
2005-08-05 21:00:03 -07:00
|
|
|
if ((cfname->zone >= 0) &&
|
2010-06-24 09:19:12 -07:00
|
|
|
((int) zone->num != cfname->zone)) continue;
|
2007-04-25 04:28:35 -07:00
|
|
|
if ((cfname->desk_x != d_x) ||
|
|
|
|
(cfname->desk_y != d_y)) continue;
|
2005-08-05 21:00:03 -07:00
|
|
|
e_desk_name_set(desk,cfname->name);
|
|
|
|
ok = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ok)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
snprintf(name, sizeof(name),
|
|
|
|
_(e_config->desktop_default_name),
|
|
|
|
d_x, d_y);
|
2005-08-05 21:00:03 -07:00
|
|
|
e_desk_name_set(desk,name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-03 01:34:24 -08:00
|
|
|
e_desk_show(E_Desk *desk)
|
|
|
|
{
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Border_List *bl;
|
|
|
|
E_Border *bd;
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Event_Desk_Show *ev;
|
2008-06-05 03:52:13 -07:00
|
|
|
E_Event_Desk_Before_Show *eev;
|
2009-02-25 14:21:46 -08:00
|
|
|
E_Event_Desk_After_Show *eeev;
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *l;
|
2009-08-21 08:08:49 -07:00
|
|
|
E_Shelf *es;
|
Larger backgrounds can now be set to scroll whenever a E changes between desks. Kind of like a transition, but uses only one (the first desk's), larger wallpaper instead of several wallpapers for all desks, and it overrides the transition settings if activated.
The option can currently be activated from Virtual Desktops Settings -> Advanced. A better home and preview would be better for these settings.
In more detail, this option can make a wallpaper, larger than the geometry of the zone, scroll appropriately with each desk change. Consider a nice panorama picture, which is as wide as the total desks' width. Then, at most, E will scroll the background by 1 / (number of desks) for each desk change. The direction of the scrolling is dependent on the desk change itself. Also, the user can specify a coefficient of maximum scrolling for each axis. If the coefficient is 0, the wallpaper will not move.
More advanced animations can be constructed with edje. The data item "directional_freedom" "(1|0) (1|0)" can toggle the actual wallpaper scrolling done by E for each axis. A message with the current x/y position, panning w|h, and zone w|h is sent to the background edje with each desk change animation tick. An example embryo script that handles the message, and changes a hypothetical "a1" part in the "e/desktop/background" group is shown below:
public message(Msg_Type:type, id, ...) {
if (type == MSG_INT_SET) {
new x = getarg(2);
new y = getarg(3);
// new max_x = getarg(4);
// new max_y = getarg(5);
// new w = getarg(6);
// new h = getarg(7);
custom_state(PART:"a1", "default", 0.0);
set_state_val(PART:"a1", STATE_FILL_POS, 0.0, 0.0, -x / 4, -y / 4);
set_state(PART:"a1", "custom", 0.0);
}
}
SVN revision: 40543
2009-05-07 11:39:55 -07:00
|
|
|
int was_zone = 0, x, y, dx = 0, dy = 0, prev_x = 0, prev_y = 0;
|
2005-05-13 03:09:55 -07:00
|
|
|
|
2005-01-03 01:34:24 -08:00
|
|
|
E_OBJECT_CHECK(desk);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
|
2005-01-03 17:32:23 -08:00
|
|
|
if (desk->visible) return;
|
2005-07-01 04:05:48 -07:00
|
|
|
|
2008-06-05 03:52:13 -07:00
|
|
|
eev = E_NEW(E_Event_Desk_Before_Show, 1);
|
|
|
|
eev->desk = e_desk_current_get(desk->zone);
|
|
|
|
e_object_ref(E_OBJECT(eev->desk));
|
2008-07-06 18:03:33 -07:00
|
|
|
ecore_event_add(E_EVENT_DESK_BEFORE_SHOW, eev,
|
2009-09-05 05:43:44 -07:00
|
|
|
_e_desk_event_desk_before_show_free, NULL);
|
2008-06-05 03:52:13 -07:00
|
|
|
|
2007-10-05 05:11:55 -07:00
|
|
|
ecore_x_window_shadow_tree_flush();
|
2005-07-01 04:05:48 -07:00
|
|
|
for (x = 0; x < desk->zone->desk_x_count; x++)
|
|
|
|
{
|
|
|
|
for (y = 0; y < desk->zone->desk_y_count; y++)
|
|
|
|
{
|
|
|
|
E_Desk *desk2;
|
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
desk2 = e_desk_at_xy_get(desk->zone, x, y);
|
|
|
|
if (desk2->visible)
|
|
|
|
{
|
|
|
|
desk2->visible = 0;
|
Larger backgrounds can now be set to scroll whenever a E changes between desks. Kind of like a transition, but uses only one (the first desk's), larger wallpaper instead of several wallpapers for all desks, and it overrides the transition settings if activated.
The option can currently be activated from Virtual Desktops Settings -> Advanced. A better home and preview would be better for these settings.
In more detail, this option can make a wallpaper, larger than the geometry of the zone, scroll appropriately with each desk change. Consider a nice panorama picture, which is as wide as the total desks' width. Then, at most, E will scroll the background by 1 / (number of desks) for each desk change. The direction of the scrolling is dependent on the desk change itself. Also, the user can specify a coefficient of maximum scrolling for each axis. If the coefficient is 0, the wallpaper will not move.
More advanced animations can be constructed with edje. The data item "directional_freedom" "(1|0) (1|0)" can toggle the actual wallpaper scrolling done by E for each axis. A message with the current x/y position, panning w|h, and zone w|h is sent to the background edje with each desk change animation tick. An example embryo script that handles the message, and changes a hypothetical "a1" part in the "e/desktop/background" group is shown below:
public message(Msg_Type:type, id, ...) {
if (type == MSG_INT_SET) {
new x = getarg(2);
new y = getarg(3);
// new max_x = getarg(4);
// new max_y = getarg(5);
// new w = getarg(6);
// new h = getarg(7);
custom_state(PART:"a1", "default", 0.0);
set_state_val(PART:"a1", STATE_FILL_POS, 0.0, 0.0, -x / 4, -y / 4);
set_state(PART:"a1", "custom", 0.0);
}
}
SVN revision: 40543
2009-05-07 11:39:55 -07:00
|
|
|
prev_x = desk2->x;
|
|
|
|
prev_y = desk2->y;
|
2006-09-01 08:37:23 -07:00
|
|
|
dx = desk->x - desk2->x;
|
|
|
|
dy = desk->y - desk2->y;
|
|
|
|
if (e_config->desk_flip_animate_mode > 0)
|
2007-04-25 04:28:35 -07:00
|
|
|
_e_desk_hide_begin(desk2, e_config->desk_flip_animate_mode,
|
|
|
|
dx, dy);
|
2006-09-01 08:37:23 -07:00
|
|
|
break;
|
|
|
|
}
|
2005-07-01 04:05:48 -07:00
|
|
|
}
|
|
|
|
}
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-09-02 00:38:40 -07:00
|
|
|
desk->zone->desk_x_current = desk->x;
|
|
|
|
desk->zone->desk_y_current = desk->y;
|
|
|
|
desk->visible = 1;
|
|
|
|
|
2005-06-29 07:28:47 -07:00
|
|
|
if (desk->zone->bg_object) was_zone = 1;
|
2006-09-01 08:37:23 -07:00
|
|
|
if (e_config->desk_flip_animate_mode == 0)
|
2005-01-03 01:34:24 -08:00
|
|
|
{
|
2006-09-01 08:37:23 -07:00
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
2005-01-05 01:31:56 -08:00
|
|
|
{
|
2006-09-01 08:37:23 -07:00
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
2005-07-21 04:15:43 -07:00
|
|
|
{
|
2006-09-01 08:37:23 -07:00
|
|
|
if ((bd->desk == desk) || (bd->sticky))
|
2008-07-06 18:03:33 -07:00
|
|
|
e_border_show(bd);
|
2006-09-01 08:37:23 -07:00
|
|
|
else if (bd->moving)
|
|
|
|
e_border_desk_set(bd, desk);
|
|
|
|
else
|
2008-07-06 18:03:33 -07:00
|
|
|
e_border_hide(bd, 2);
|
2005-07-21 04:15:43 -07:00
|
|
|
}
|
2005-01-05 01:31:56 -08:00
|
|
|
}
|
2006-09-01 08:37:23 -07:00
|
|
|
e_container_border_list_free(bl);
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
2005-07-12 04:07:57 -07:00
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
if (e_config->desk_flip_animate_mode > 0)
|
|
|
|
_e_desk_show_begin(desk, e_config->desk_flip_animate_mode, dx, dy);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-07-12 04:07:57 -07:00
|
|
|
if (e_config->focus_last_focused_per_desktop)
|
|
|
|
e_desk_last_focused_focus(desk);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-06-29 07:28:47 -07:00
|
|
|
if (was_zone)
|
Larger backgrounds can now be set to scroll whenever a E changes between desks. Kind of like a transition, but uses only one (the first desk's), larger wallpaper instead of several wallpapers for all desks, and it overrides the transition settings if activated.
The option can currently be activated from Virtual Desktops Settings -> Advanced. A better home and preview would be better for these settings.
In more detail, this option can make a wallpaper, larger than the geometry of the zone, scroll appropriately with each desk change. Consider a nice panorama picture, which is as wide as the total desks' width. Then, at most, E will scroll the background by 1 / (number of desks) for each desk change. The direction of the scrolling is dependent on the desk change itself. Also, the user can specify a coefficient of maximum scrolling for each axis. If the coefficient is 0, the wallpaper will not move.
More advanced animations can be constructed with edje. The data item "directional_freedom" "(1|0) (1|0)" can toggle the actual wallpaper scrolling done by E for each axis. A message with the current x/y position, panning w|h, and zone w|h is sent to the background edje with each desk change animation tick. An example embryo script that handles the message, and changes a hypothetical "a1" part in the "e/desktop/background" group is shown below:
public message(Msg_Type:type, id, ...) {
if (type == MSG_INT_SET) {
new x = getarg(2);
new y = getarg(3);
// new max_x = getarg(4);
// new max_y = getarg(5);
// new w = getarg(6);
// new h = getarg(7);
custom_state(PART:"a1", "default", 0.0);
set_state_val(PART:"a1", STATE_FILL_POS, 0.0, 0.0, -x / 4, -y / 4);
set_state(PART:"a1", "custom", 0.0);
}
}
SVN revision: 40543
2009-05-07 11:39:55 -07:00
|
|
|
{
|
|
|
|
if (e_config->desk_flip_pan_bg)
|
|
|
|
e_bg_zone_slide(desk->zone, prev_x, prev_y);
|
|
|
|
else
|
|
|
|
e_bg_zone_update(desk->zone, E_BG_TRANSITION_DESK);
|
|
|
|
}
|
2005-06-29 07:28:47 -07:00
|
|
|
else
|
|
|
|
e_bg_zone_update(desk->zone, E_BG_TRANSITION_START);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-02-15 04:11:31 -08:00
|
|
|
ev = E_NEW(E_Event_Desk_Show, 1);
|
|
|
|
ev->desk = desk;
|
|
|
|
e_object_ref(E_OBJECT(desk));
|
2009-09-05 05:43:44 -07:00
|
|
|
ecore_event_add(E_EVENT_DESK_SHOW, ev, _e_desk_event_desk_show_free, NULL);
|
2007-09-04 16:59:01 -07:00
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_shelf_list(), l, es)
|
2007-09-04 16:59:01 -07:00
|
|
|
{
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *ll;
|
2007-09-26 05:34:38 -07:00
|
|
|
E_Config_Shelf *cf_es;
|
|
|
|
E_Zone *zone;
|
2009-08-21 08:08:49 -07:00
|
|
|
E_Config_Shelf_Desk *sd;
|
2007-09-04 16:59:01 -07:00
|
|
|
int show_shelf=0;
|
|
|
|
|
2007-09-26 05:34:38 -07:00
|
|
|
if (!es) continue;
|
2007-09-04 16:59:01 -07:00
|
|
|
if (!es->cfg->desk_show_mode) continue;
|
2007-09-26 05:34:38 -07:00
|
|
|
cf_es = es->cfg;
|
|
|
|
if (!cf_es) continue;
|
|
|
|
|
2008-07-06 18:03:33 -07:00
|
|
|
zone = e_util_zone_current_get(e_manager_current_get());
|
2010-06-24 09:19:12 -07:00
|
|
|
if (cf_es->zone != (int) zone->num) continue;
|
2007-09-04 16:59:01 -07:00
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(es->cfg->desk_list, ll, sd)
|
2007-09-04 16:59:01 -07:00
|
|
|
{
|
|
|
|
if (!sd) continue;
|
|
|
|
if ((desk->x == sd->x) && (desk->y == sd->y))
|
|
|
|
{
|
2008-07-06 18:03:33 -07:00
|
|
|
show_shelf = 1;
|
2007-09-04 16:59:01 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (show_shelf)
|
2007-11-15 12:16:25 -08:00
|
|
|
e_shelf_show(es);
|
2007-09-04 16:59:01 -07:00
|
|
|
else
|
2007-11-15 12:16:25 -08:00
|
|
|
e_shelf_hide(es);
|
2007-09-04 16:59:01 -07:00
|
|
|
}
|
2009-02-25 14:21:46 -08:00
|
|
|
|
|
|
|
if (e_config->desk_flip_animate_mode == 0)
|
|
|
|
{
|
|
|
|
eeev = E_NEW(E_Event_Desk_After_Show, 1);
|
|
|
|
eeev->desk = e_desk_current_get(desk->zone);
|
|
|
|
e_object_ref(E_OBJECT(eeev->desk));
|
|
|
|
ecore_event_add(E_EVENT_DESK_AFTER_SHOW, eeev,
|
2009-09-05 05:43:44 -07:00
|
|
|
_e_desk_event_desk_after_show_free, NULL);
|
2009-02-25 14:21:46 -08:00
|
|
|
}
|
|
|
|
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
|
|
|
|
2006-07-22 15:25:04 -07:00
|
|
|
EAPI void
|
|
|
|
e_desk_deskshow(E_Zone *zone)
|
|
|
|
{
|
|
|
|
E_Border *bd;
|
|
|
|
E_Border_List *bl;
|
|
|
|
E_Desk *desk;
|
|
|
|
E_Event_Desk_Show *ev;
|
|
|
|
|
|
|
|
E_OBJECT_CHECK(zone);
|
|
|
|
E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
|
|
|
|
|
|
|
|
desk = e_desk_current_get(zone);
|
|
|
|
bl = e_container_border_list_first(zone->container);
|
2007-10-05 05:11:55 -07:00
|
|
|
ecore_x_window_shadow_tree_flush();
|
2006-07-22 15:25:04 -07:00
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if (bd->desk == desk)
|
|
|
|
{
|
|
|
|
if (desk->deskshow_toggle)
|
|
|
|
{
|
|
|
|
if (bd->deskshow) e_border_uniconify(bd);
|
|
|
|
bd->deskshow = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (bd->iconic) continue;
|
|
|
|
if (bd->client.netwm.state.skip_taskbar) continue;
|
|
|
|
if (bd->user_skip_winlist) continue;
|
|
|
|
e_border_iconify(bd);
|
|
|
|
bd->deskshow = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
desk->deskshow_toggle = desk->deskshow_toggle ? 0 : 1;
|
|
|
|
e_container_border_list_free(bl);
|
|
|
|
ev = E_NEW(E_Event_Desk_Show, 1);
|
|
|
|
ev->desk = desk;
|
|
|
|
e_object_ref(E_OBJECT(desk));
|
|
|
|
ecore_event_add(E_EVENT_DESK_DESKSHOW, ev,
|
2009-09-05 05:43:44 -07:00
|
|
|
_e_desk_event_desk_deskshow_free, NULL);
|
2006-07-22 15:25:04 -07:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-07-12 04:07:57 -07:00
|
|
|
e_desk_last_focused_focus(E_Desk *desk)
|
|
|
|
{
|
2008-10-22 04:49:33 -07:00
|
|
|
Eina_List *l = NULL;
|
2005-07-12 04:07:57 -07:00
|
|
|
E_Border *bd;
|
2008-08-28 20:30:45 -07:00
|
|
|
|
2009-08-21 08:08:49 -07:00
|
|
|
EINA_LIST_FOREACH(e_border_focus_stack_get(), l, bd)
|
2005-07-12 04:07:57 -07:00
|
|
|
{
|
2008-08-28 20:30:45 -07:00
|
|
|
if ((!bd->iconic) && (bd->visible) && (bd->desk == desk) &&
|
|
|
|
(bd->client.icccm.accepts_focus || bd->client.icccm.take_focus) &&
|
|
|
|
(bd->client.netwm.type != ECORE_X_WINDOW_TYPE_DOCK) &&
|
|
|
|
(bd->client.netwm.type != ECORE_X_WINDOW_TYPE_TOOLBAR) &&
|
|
|
|
(bd->client.netwm.type != ECORE_X_WINDOW_TYPE_MENU) &&
|
|
|
|
(bd->client.netwm.type != ECORE_X_WINDOW_TYPE_SPLASH) &&
|
|
|
|
(bd->client.netwm.type != ECORE_X_WINDOW_TYPE_DESKTOP)
|
|
|
|
)
|
2005-07-12 04:07:57 -07:00
|
|
|
{
|
|
|
|
/* this was the window last focused in this desktop */
|
2008-08-10 18:22:33 -07:00
|
|
|
if (!bd->lock_focus_out)
|
|
|
|
e_border_focus_set(bd, 1, 1);
|
2005-07-12 04:07:57 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-08 06:41:21 -08:00
|
|
|
e_desk_row_add(E_Zone *zone)
|
|
|
|
{
|
2005-01-08 09:32:08 -08:00
|
|
|
e_zone_desk_count_set(zone, zone->desk_x_count, zone->desk_y_count + 1);
|
2005-01-08 06:41:21 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-08 06:41:21 -08:00
|
|
|
e_desk_row_remove(E_Zone *zone)
|
|
|
|
{
|
2005-01-08 09:32:08 -08:00
|
|
|
e_zone_desk_count_set(zone, zone->desk_x_count, zone->desk_y_count - 1);
|
2005-01-08 06:41:21 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-08 06:41:21 -08:00
|
|
|
e_desk_col_add(E_Zone *zone)
|
|
|
|
{
|
2005-01-08 09:32:08 -08:00
|
|
|
e_zone_desk_count_set(zone, zone->desk_x_count + 1, zone->desk_y_count);
|
2005-01-08 06:41:21 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-08 06:41:21 -08:00
|
|
|
e_desk_col_remove(E_Zone *zone)
|
|
|
|
{
|
2005-01-08 09:32:08 -08:00
|
|
|
e_zone_desk_count_set(zone, zone->desk_x_count - 1, zone->desk_y_count);
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
2005-01-08 09:32:08 -08:00
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI E_Desk *
|
2005-01-03 01:34:24 -08:00
|
|
|
e_desk_current_get(E_Zone *zone)
|
|
|
|
{
|
2005-01-03 14:04:04 -08:00
|
|
|
E_OBJECT_CHECK_RETURN(zone, NULL);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-08 09:32:08 -08:00
|
|
|
return e_desk_at_xy_get(zone, zone->desk_x_current, zone->desk_y_current);
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI E_Desk *
|
2005-01-08 09:32:08 -08:00
|
|
|
e_desk_at_xy_get(E_Zone *zone, int x, int y)
|
|
|
|
{
|
|
|
|
E_OBJECT_CHECK_RETURN(zone, NULL);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
|
2005-01-08 09:32:08 -08:00
|
|
|
|
2005-03-22 10:51:35 -08:00
|
|
|
if ((x >= zone->desk_x_count) || (y >= zone->desk_y_count))
|
2005-01-20 02:42:09 -08:00
|
|
|
return NULL;
|
2005-12-03 19:25:34 -08:00
|
|
|
else if ((x < 0) || (y < 0))
|
|
|
|
return NULL;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-04-22 00:54:08 -07:00
|
|
|
return zone->desks[x + (y * zone->desk_x_count)];
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI E_Desk *
|
2005-05-17 05:33:12 -07:00
|
|
|
e_desk_at_pos_get(E_Zone *zone, int pos)
|
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
E_OBJECT_CHECK_RETURN(zone, NULL);
|
|
|
|
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
|
|
|
|
|
|
|
|
y = pos / zone->desk_x_count;
|
|
|
|
x = pos - (y * zone->desk_x_count);
|
|
|
|
|
|
|
|
if ((x >= zone->desk_x_count) || (y >= zone->desk_y_count))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return zone->desks[x + (y * zone->desk_x_count)];
|
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-20 06:01:31 -08:00
|
|
|
e_desk_xy_get(E_Desk *desk, int *x, int *y)
|
|
|
|
{
|
|
|
|
E_OBJECT_CHECK(desk);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
|
2005-01-20 06:01:31 -08:00
|
|
|
|
2005-04-08 17:13:09 -07:00
|
|
|
if (x) *x = desk->x;
|
|
|
|
if (y) *y = desk->y;
|
2005-01-20 06:01:31 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-03 01:34:24 -08:00
|
|
|
e_desk_next(E_Zone *zone)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
int x, y;
|
2005-01-03 01:34:24 -08:00
|
|
|
|
|
|
|
E_OBJECT_CHECK(zone);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2007-04-25 04:28:35 -07:00
|
|
|
if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
|
2005-04-08 17:13:09 -07:00
|
|
|
return;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-08 06:41:21 -08:00
|
|
|
x = zone->desk_x_current;
|
|
|
|
y = zone->desk_y_current;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-08 06:41:21 -08:00
|
|
|
x++;
|
2005-03-22 10:51:35 -08:00
|
|
|
if (x >= zone->desk_x_count)
|
2005-01-08 06:41:21 -08:00
|
|
|
{
|
|
|
|
x = 0;
|
|
|
|
y++;
|
2005-04-08 17:13:09 -07:00
|
|
|
if (y >= zone->desk_y_count) y = 0;
|
2005-01-08 06:41:21 -08:00
|
|
|
}
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2005-01-08 09:32:08 -08:00
|
|
|
e_desk_show(e_desk_at_xy_get(zone, x, y));
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
|
|
|
|
2006-01-07 02:39:46 -08:00
|
|
|
EAPI void
|
2005-01-03 01:34:24 -08:00
|
|
|
e_desk_prev(E_Zone *zone)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
int x, y;
|
2005-01-03 01:34:24 -08:00
|
|
|
|
|
|
|
E_OBJECT_CHECK(zone);
|
2005-01-21 22:58:34 -08:00
|
|
|
E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
|
2005-01-03 01:34:24 -08:00
|
|
|
|
2007-04-25 04:28:35 -07:00
|
|
|
if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
|
2005-01-08 06:41:21 -08:00
|
|
|
return;
|
|
|
|
|
|
|
|
x = zone->desk_x_current;
|
|
|
|
y = zone->desk_y_current;
|
|
|
|
|
|
|
|
x--;
|
|
|
|
if (x < 0)
|
|
|
|
{
|
|
|
|
x = zone->desk_x_count - 1;
|
|
|
|
y--;
|
2005-04-08 17:13:09 -07:00
|
|
|
if (y < 0) y = zone->desk_y_count - 1;
|
2005-01-08 06:41:21 -08:00
|
|
|
}
|
2005-01-08 09:32:08 -08:00
|
|
|
e_desk_show(e_desk_at_xy_get(zone, x, y));
|
2005-01-03 01:34:24 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_e_desk_free(E_Desk *desk)
|
|
|
|
{
|
2008-10-15 08:12:56 -07:00
|
|
|
if (desk->name) eina_stringshare_del(desk->name);
|
2006-09-01 08:37:23 -07:00
|
|
|
if (desk->animator) ecore_animator_del(desk->animator);
|
2005-01-03 01:34:24 -08:00
|
|
|
free(desk);
|
|
|
|
}
|
|
|
|
|
2005-02-15 04:11:31 -08:00
|
|
|
static void
|
2010-11-05 11:40:31 -07:00
|
|
|
_e_desk_event_desk_show_free(void *data __UNUSED__, void *event)
|
2005-02-15 04:11:31 -08:00
|
|
|
{
|
|
|
|
E_Event_Desk_Show *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
e_object_unref(E_OBJECT(ev->desk));
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
2008-06-05 03:52:13 -07:00
|
|
|
static void
|
2010-11-05 11:40:31 -07:00
|
|
|
_e_desk_event_desk_before_show_free(void *data __UNUSED__, void *event)
|
2008-06-05 03:52:13 -07:00
|
|
|
{
|
|
|
|
E_Event_Desk_Before_Show *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
e_object_unref(E_OBJECT(ev->desk));
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
2009-02-25 14:21:46 -08:00
|
|
|
static void
|
2010-11-05 11:40:31 -07:00
|
|
|
_e_desk_event_desk_after_show_free(void *data __UNUSED__, void *event)
|
2009-02-25 14:21:46 -08:00
|
|
|
{
|
|
|
|
E_Event_Desk_After_Show *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
e_object_unref(E_OBJECT(ev->desk));
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
2006-07-22 15:25:04 -07:00
|
|
|
static void
|
2010-11-05 11:40:31 -07:00
|
|
|
_e_desk_event_desk_deskshow_free(void *data __UNUSED__, void *event)
|
2006-07-22 15:25:04 -07:00
|
|
|
{
|
|
|
|
E_Event_Desk_Show *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
e_object_unref(E_OBJECT(ev->desk));
|
|
|
|
free(ev);
|
|
|
|
}
|
|
|
|
|
2005-09-05 16:14:58 -07:00
|
|
|
static void
|
2010-11-05 11:40:31 -07:00
|
|
|
_e_desk_event_desk_name_change_free(void *data __UNUSED__, void *event)
|
2005-09-05 16:14:58 -07:00
|
|
|
{
|
|
|
|
E_Event_Desk_Name_Change *ev;
|
|
|
|
|
|
|
|
ev = event;
|
|
|
|
e_object_unref(E_OBJECT(ev->desk));
|
|
|
|
free(ev);
|
|
|
|
}
|
2006-09-01 08:37:23 -07:00
|
|
|
|
|
|
|
static void
|
|
|
|
_e_desk_show_begin(E_Desk *desk, int mode, int dx, int dy)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
|
|
|
E_Border *bd;
|
|
|
|
double t;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
2008-11-01 19:36:10 -07:00
|
|
|
t = ecore_loop_time_get();
|
2006-09-01 08:37:23 -07:00
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
|
|
|
{
|
|
|
|
bd->fx.start.t = t;
|
|
|
|
bd->fx.start.x = 0;
|
|
|
|
bd->fx.start.y = 0;
|
|
|
|
e_border_desk_set(bd, desk);
|
|
|
|
e_border_show(bd);
|
|
|
|
}
|
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
|
|
|
{
|
|
|
|
bd->fx.start.t = t;
|
|
|
|
if (mode == 1)
|
|
|
|
{
|
|
|
|
bd->fx.start.x = bd->zone->w * dx;
|
|
|
|
bd->fx.start.y = bd->zone->h * dy;
|
|
|
|
}
|
|
|
|
else if (mode == 2)
|
|
|
|
{
|
|
|
|
int mx, my, bx, by;
|
|
|
|
double fx, fy, ang, rad, len, lmax;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
mx = bd->zone->x + (bd->zone->w / 2);
|
|
|
|
my = bd->zone->y + (bd->zone->h / 2);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
bx = bd->x + (bd->w / 2) - mx;
|
|
|
|
by = bd->y + (bd->h / 2) - my;
|
|
|
|
if (bx == 0) bx = 1;
|
|
|
|
if (by == 0) by = 1;
|
|
|
|
fx = (double)bx / (double)(bd->zone->w / 2);
|
|
|
|
fy = (double)by / (double)(bd->zone->h / 2);
|
|
|
|
ang = atan(fy / fx);
|
|
|
|
if (fx < 0.0)
|
|
|
|
ang = M_PI + ang;
|
|
|
|
len = sqrt((bx * bx) + (by * by));
|
|
|
|
lmax = sqrt(((bd->zone->w / 2) * (bd->zone->w / 2)) +
|
|
|
|
((bd->zone->h / 2) * (bd->zone->h / 2)));
|
|
|
|
rad = sqrt((bd->w * bd->w) + (bd->h * bd->h)) / 2.0;
|
|
|
|
bx = cos(ang) * (lmax - len + rad);
|
|
|
|
by = sin(ang) * (lmax - len + rad);
|
|
|
|
bd->fx.start.x = bx;
|
|
|
|
bd->fx.start.y = by;
|
|
|
|
}
|
2006-09-04 06:38:35 -07:00
|
|
|
if (bd->fx.start.x < 0)
|
|
|
|
bd->fx.start.x -= bd->zone->x;
|
|
|
|
else
|
|
|
|
bd->fx.start.x += bd->zone->container->w - (bd->zone->x + bd->zone->w);
|
|
|
|
if (bd->fx.start.y < 0)
|
|
|
|
bd->fx.start.y -= bd->zone->y;
|
|
|
|
else
|
|
|
|
bd->fx.start.y += bd->zone->container->h - (bd->zone->y + bd->zone->h);
|
2006-09-01 08:37:23 -07:00
|
|
|
e_border_fx_offset(bd, bd->fx.start.x, bd->fx.start.y);
|
|
|
|
e_border_show(bd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
|
|
|
if (desk->animator) ecore_animator_del(desk->animator);
|
|
|
|
desk->animator = ecore_animator_add(_e_desk_show_animator, desk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_e_desk_show_end(E_Desk *desk)
|
|
|
|
{
|
2009-02-25 14:21:46 -08:00
|
|
|
E_Event_Desk_After_Show *ev;
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
|
|
|
E_Border *bd;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
2007-04-25 04:28:35 -07:00
|
|
|
e_border_fx_offset(bd, 0, 0);
|
2006-09-01 08:37:23 -07:00
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
2007-04-25 04:28:35 -07:00
|
|
|
e_border_fx_offset(bd, 0, 0);
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
2007-10-05 05:11:55 -07:00
|
|
|
ecore_x_window_shadow_tree_flush();
|
2009-02-25 14:21:46 -08:00
|
|
|
ev = E_NEW(E_Event_Desk_After_Show, 1);
|
|
|
|
ev->desk = e_desk_current_get(desk->zone);
|
|
|
|
e_object_ref(E_OBJECT(ev->desk));
|
|
|
|
ecore_event_add(E_EVENT_DESK_AFTER_SHOW, ev,
|
2009-09-05 05:43:44 -07:00
|
|
|
_e_desk_event_desk_after_show_free, NULL);
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:19:12 -07:00
|
|
|
static Eina_Bool
|
2006-09-01 08:37:23 -07:00
|
|
|
_e_desk_show_animator(void *data)
|
|
|
|
{
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Desk *desk;
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Border *bd;
|
|
|
|
double t, dt, spd;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
|
|
|
desk = data;
|
2008-11-01 19:36:10 -07:00
|
|
|
t = ecore_loop_time_get();
|
2006-09-01 08:37:23 -07:00
|
|
|
dt = -1.0;
|
|
|
|
spd = e_config->desk_flip_animate_time;
|
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
|
|
|
{
|
|
|
|
dt = (t - bd->fx.start.t) / spd;
|
|
|
|
if (dt > 1.0) dt = 1.0;
|
|
|
|
dt = 1.0 - dt;
|
2007-03-25 15:45:00 -07:00
|
|
|
dt *= dt; /* decelerate - could be a better hack */
|
2006-09-01 08:37:23 -07:00
|
|
|
e_border_fx_offset(bd,
|
|
|
|
((double)bd->fx.start.x * dt),
|
|
|
|
((double)bd->fx.start.y * dt));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
|
|
|
if (dt <= 0.0)
|
|
|
|
{
|
|
|
|
_e_desk_show_end(desk);
|
|
|
|
desk->animator = NULL;
|
2010-06-24 09:19:12 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
2010-06-24 09:19:12 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_e_desk_hide_begin(E_Desk *desk, int mode, int dx, int dy)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
|
|
|
E_Border *bd;
|
|
|
|
double t;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
2008-11-01 19:36:10 -07:00
|
|
|
t = ecore_loop_time_get();
|
2006-09-01 08:37:23 -07:00
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
|
|
|
{
|
|
|
|
bd->fx.start.t = t;
|
|
|
|
bd->fx.start.x = 0;
|
|
|
|
bd->fx.start.y = 0;
|
|
|
|
}
|
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
|
|
|
{
|
|
|
|
bd->fx.start.t = t;
|
|
|
|
if (mode == 1)
|
|
|
|
{
|
|
|
|
bd->fx.start.x = bd->zone->w * -dx;
|
|
|
|
bd->fx.start.y = bd->zone->h * -dy;
|
|
|
|
}
|
|
|
|
else if (mode == 2)
|
|
|
|
{
|
|
|
|
int mx, my, bx, by;
|
|
|
|
double fx, fy, ang, rad, len, lmax;
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
mx = bd->zone->x + (bd->zone->w / 2);
|
|
|
|
my = bd->zone->y + (bd->zone->h / 2);
|
2008-07-06 18:03:33 -07:00
|
|
|
|
2006-09-01 08:37:23 -07:00
|
|
|
bx = bd->x + (bd->w / 2) - mx;
|
|
|
|
by = bd->y + (bd->h / 2) - my;
|
|
|
|
if (bx == 0) bx = 1;
|
|
|
|
if (by == 0) by = 1;
|
|
|
|
fx = (double)bx / (double)(bd->zone->w / 2);
|
|
|
|
fy = (double)by / (double)(bd->zone->h / 2);
|
|
|
|
ang = atan(fy / fx);
|
|
|
|
if (fx < 0.0)
|
|
|
|
ang = M_PI + ang;
|
|
|
|
len = sqrt((bx * bx) + (by * by));
|
|
|
|
lmax = sqrt(((bd->zone->w / 2) * (bd->zone->w / 2)) +
|
|
|
|
((bd->zone->h / 2) * (bd->zone->h / 2)));
|
|
|
|
rad = sqrt((bd->w * bd->w) + (bd->h * bd->h)) / 2.0;
|
|
|
|
bx = cos(ang) * (lmax - len + rad);
|
|
|
|
by = sin(ang) * (lmax - len + rad);
|
|
|
|
bd->fx.start.x = bx;
|
|
|
|
bd->fx.start.y = by;
|
|
|
|
}
|
2006-09-04 06:38:35 -07:00
|
|
|
if (bd->fx.start.x < 0)
|
|
|
|
bd->fx.start.x -= bd->zone->x;
|
|
|
|
else
|
|
|
|
bd->fx.start.x += bd->zone->container->w - (bd->zone->x + bd->zone->w);
|
|
|
|
if (bd->fx.start.y < 0)
|
|
|
|
bd->fx.start.y -= bd->zone->y;
|
|
|
|
else
|
|
|
|
bd->fx.start.y += bd->zone->container->h - (bd->zone->y + bd->zone->h);
|
2006-09-01 08:37:23 -07:00
|
|
|
e_border_fx_offset(bd, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
|
|
|
if (desk->animator) ecore_animator_del(desk->animator);
|
|
|
|
desk->animator = ecore_animator_add(_e_desk_hide_animator, desk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_e_desk_hide_end(E_Desk *desk)
|
|
|
|
{
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Border *bd;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
2007-04-25 04:28:35 -07:00
|
|
|
e_border_fx_offset(bd, 0, 0);
|
2006-09-01 08:37:23 -07:00
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
|
|
|
{
|
|
|
|
e_border_fx_offset(bd, 0, 0);
|
|
|
|
e_border_hide(bd, 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
2007-10-05 05:11:55 -07:00
|
|
|
ecore_x_window_shadow_tree_flush();
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
|
|
|
|
2010-06-24 09:19:12 -07:00
|
|
|
static Eina_Bool
|
2006-09-01 08:37:23 -07:00
|
|
|
_e_desk_hide_animator(void *data)
|
|
|
|
{
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Desk *desk;
|
2007-04-25 04:28:35 -07:00
|
|
|
E_Border_List *bl;
|
2008-07-06 18:03:33 -07:00
|
|
|
E_Border *bd;
|
|
|
|
double t, dt, spd;
|
2006-09-01 08:37:23 -07:00
|
|
|
|
|
|
|
desk = data;
|
2008-11-01 19:36:10 -07:00
|
|
|
t = ecore_loop_time_get();
|
2006-09-01 08:37:23 -07:00
|
|
|
dt = -1.0;
|
|
|
|
spd = e_config->desk_flip_animate_time;
|
|
|
|
bl = e_container_border_list_first(desk->zone->container);
|
|
|
|
while ((bd = e_container_border_list_next(bl)))
|
|
|
|
{
|
|
|
|
if ((bd->desk->zone == desk->zone) && (!bd->iconic))
|
|
|
|
{
|
|
|
|
if (bd->moving)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
else if ((bd->desk == desk) && (!bd->sticky))
|
|
|
|
{
|
|
|
|
dt = (t - bd->fx.start.t) / spd;
|
|
|
|
if (dt > 1.0) dt = 1.0;
|
2007-03-25 15:45:00 -07:00
|
|
|
dt *= dt; /* decelerate - could be a better hack */
|
2006-09-01 08:37:23 -07:00
|
|
|
e_border_fx_offset(bd,
|
|
|
|
((double)bd->fx.start.x * dt),
|
|
|
|
((double)bd->fx.start.y * dt));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e_container_border_list_free(bl);
|
|
|
|
if ((dt < 0.0) || (dt >= 1.0))
|
|
|
|
{
|
|
|
|
_e_desk_hide_end(desk);
|
|
|
|
desk->animator = NULL;
|
2010-06-24 09:19:12 -07:00
|
|
|
return ECORE_CALLBACK_CANCEL;
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|
2010-06-24 09:19:12 -07:00
|
|
|
return ECORE_CALLBACK_RENEW;
|
2006-09-01 08:37:23 -07:00
|
|
|
}
|